HTTP协议

转载 2016年08月29日 10:07:54
  1. HTTP由两部分组成:请求和响应。当你在Web浏览器中输入一个URL时,浏览器将根据你的要求创建并发送请求,该请求包含所输入的URL以及一些与浏览器本身相关的信息。当服务器收到这个请求时将返回一个响应,该响应包括与该请求相关的信息以及位于指定URL(如果有的话)的数据。直到浏览器解析该响应并显示出网页(或其他资源)为止。  
  2.   
  3. HTTP请求  
  4.   
  5. HTTP请求的格式如下所示:  
  6.   
  7. <request-line>  
  8. <headers>  
  9. <blank line>  
  10. [<request-body>]  
  11.   
  12. 在HTTP请求中,第一行必须是一个请求行(request line),用来说明请求类型、要访问的资源以及使用的HTTP版本。紧接着是一个首部(header)小节,用来说明服务器要使用的附加信息。在首部之后是一个空行,再此之后可以添加任意的其他数据[称之为主体(body)]。  
  13.   
  14. 在HTTP中,定义了多种请求类型,通常我们关心的只有GET请求和POST请求。只要在Web浏览器上输入一个URL,浏览器就将基于该URL向服务器发送一个GET请求,以告诉服务器获取并返回什么资源。对于www.baidu.com的GET请求如下所示:  
  15.   
  16. GET / HTTP/1.1  
  17. Host: www.baidu.com  
  18. User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.7.6)  
  19. Gecko/20050225 Firefox/1.0.1  
  20. Connection: Keep-Alive  
  21.   
  22. 请求行的第一部分说明了该请求是GET请求。该行的第二部分是一个斜杠(/),用来说明请求的是该域名的根目录。该行的最后一部分说明使用的是HTTP 1.1版本(另一个可选项是1.0)。那么请求发到哪里去呢?这就是第二行的内容。  
  23.   
  24. 2行是请求的第一个首部,HOST。首部HOST将指出请求的目的地。结合HOST和上一行中的斜杠(/),可以通知服务器请求的是www.baidu.com/(HTTP 1.1才需要使用首部HOST,而原来的1.0版本则不需要使用)。第三行中包含的是首部User-Agent,服务器端和客户端脚本都能够访问它,它是浏览器类型检测逻辑的重要基础。该信息由你使用的浏览器来定义(在本例中是Firefox 1.0.1),并且在每个请求中将自动发送。最后一行是首部Connection,通常将浏览器操作设置为Keep-Alive(当然也可以设置为其他值)。注意,在最后一个首部之后有一个空行。即使不存在请求主体,这个空行也是必需的。  
  25.   
  26. 要发送GET请求的参数,则必须将这些额外的信息附在URL本身的后面。其格式类似于:  
  27.   
  28. URL ? name1=value1&name2=value2&..&nameN=valueN  
  29.   
  30. 该信息称之为查询字符串(query string),它将会复制在HTTP请求的请求行中,如下所示:  
  31.   
  32. GET /books/?name=Professional%20Ajax HTTP/1.1  
  33. Host: www.baidu.com  
  34. User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.7.6)  
  35. Gecko/20050225 Firefox/1.0.1  
  36. Connection: Keep-Alive  
  37.   
  38. 注意,为了将文本“Professional Ajax”作为URL的参数,需要编码处理其内容,将空格替换成%20,这称为URL编码(URL encoding),常用于HTTP的许多地方(JavaScript提供了内建的函数来处理URL编码和解码)。“名称—值”(name—value)对用 & 隔开。绝大部分的服务器端技术能够自动对请求主体进行解码,并为这些值的访问提供一些逻辑方式。当然,如何使用这些数据还是由服务器决定的。  
  39.   
  40. 另一方面,POST请求在请求主体中为服务器提供了一些附加的信息。通常,当填写一个在线表单并提交它时,这些填入的数据将以POST请求的方式发送给服务器。  
  41.   
  42. 以下就是一个典型的POST请求:  
  43.   
  44. POST / HTTP/1.1  
  45. Host: www.baidu.com  
  46. User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.7.6)  
  47. Gecko/20050225 Firefox/1.0.1  
  48. Content-Type: application/x-www-form-urlencoded  
  49. Content-Length: 40  
  50. Connection: Keep-Alive  
  51.   
  52. name=Professional%20Ajax&publisher=Wiley  
  53.   
  54. 从上面可以发现, POST请求和GET请求之间有一些区别。首先,请求行开始处的GET改为了POST,以表示不同的请求类型。你会发现首部Host和User-Agent仍然存在,在后面有两个新行。其中首部Content-Type说明了请求主体的内容是如何编码的。浏览器始终以application/ x-www-form- urlencoded的格式编码来传送数据,这是针对简单URL编码的MIME类型。首部Content-Length说明了请求主体的字节数。在首部Connection后是一个空行,再后面就是请求主体。与大多数浏览器的POST请求一样,这是以简单的“名称—值”对的形式给出的,其中name是Professional Ajax,publisher是Wiley。你可以以同样的格式来组织URL的查询字符串参数。  
  55.   
  56. 下面是一些最常见的请求头:  
  57.   
  58.     Accept:浏览器可接受的MIME类型。  
  59.     Accept - Charset:浏览器可接受的字符集。  
  60.     Accept - Encoding:浏览器能够进行解码的数据编码方式,比如gzip。Servlet能够向支持gzip的浏览器返回经gzip编码的HTML页面。许多情形下这可以减少510倍的下载时间。  
  61.     Accept - Language:浏览器所希望的语言种类,当服务器能够提供一种以上的语言版本时要用到。  
  62.     Authorization:授权信息,通常出现在对服务器发送的WWW - Authenticate头的应答中。  
  63.     Connection:表示是否需要持久连接。如果Servlet看到这里的值为“Keep - Alive”,或者看到请求使用的是HTTP 1.1(HTTP 1.1默认进行持久连接),它就可以利用持久连接的优点,当页面包含多个元素时(例如Applet,图片),显著地减少下载所需要的时间。要实现这一点,Servlet需要在应答中发送一个Content - Length头,最简单的实现方法是:先把内容写入ByteArrayOutputStream,然后在正式写出内容之前计算它的大小。  
  64.     Content - Length:表示请求消息正文的长度。  
  65.     Cookie:这是最重要的请求头信息之一,参见后面《Cookie处理》一章中的讨论。  
  66.     From:请求发送者的email地址,由一些特殊的Web客户程序使用,浏览器不会用到它。  
  67.     Host:初始URL中的主机和端口。  
  68.     If - Modified - Since:只有当所请求的内容在指定的日期之后又经过修改才返回它,否则返回304“Not Modified”应答。  
  69.     Pragma:指定“no - cache”值表示服务器必须返回一个刷新后的文档,即使它是代理服务器而且已经有了页面的本地拷贝。  
  70.     Referer:包含一个URL,用户从该URL代表的页面出发访问当前请求的页面。  
  71.     User - Agent:浏览器类型,如果Servlet返回的内容与浏览器类型有关则该值非常有用。  
  72.     UA - Pixels,UA - Color,UA - OS,UA - CPU:由某些版本的IE浏览器所发送的非标准的请求头,表示屏幕大小、颜色深度、操作系统和CPU类型。  
  73.   
  74.   
  75. HTTP响应  
  76.   
  77. 如下所示,HTTP响应的格式与请求的格式十分类似:  
  78. <status-line>  
  79. <headers>  
  80. <blank line>  
  81. [<response-body>]  
  82.   
  83. 正如你所见,在响应中唯一真正的区别在于第一行中用状态信息代替了请求信息。状态行(status line)通过提供一个状态码来说明所请求的资源情况。以下就是一个HTTP响应的例子:  
  84.   
  85. HTTP/1.1 200 OK  
  86. Date: Sat, 31 Dec 2005 23:59:59 GMT  
  87. Content-Type: text/html;charset=ISO-8859-1  
  88. Content-Length: 122  
  89.   
  90. <html>  
  91. <head>  
  92. <title>Wrox Homepage</title>  
  93. </head>  
  94. <body>  
  95. <!-- body goes here -->  
  96. </body>  
  97. </html>  
  98.   
  99. 在本例中,状态行给出的HTTP状态代码是200,以及消息OK。状态行始终包含的是状态码和相应的简短消息,以避免混乱。最常用的状态码有:  
  100. 200 (OK): 找到了该资源,并且一切正常。  
  101. 304 (NOT MODIFIED): 该资源在上次请求之后没有任何修改。这通常用于浏览器的缓存机制。  
  102. 401 (UNAUTHORIZED): 客户端无权访问该资源。这通常会使得浏览器要求用户输入用户名和密码,以登录到服务器。  
  103. 403 (FORBIDDEN): 客户端未能获得授权。这通常是在401之后输入了不正确的用户名或密码。  
  104. 404 (NOT FOUND): 在指定的位置不存在所申请的资源。  
  105.   
  106. 在状态行之后是一些首部。通常,服务器会返回一个名为Data的首部,用来说明响应生成的日期和时间(服务器通常还会返回一些关于其自身的信息,尽管并非是必需的)。接下来的两个首部大家应该熟悉,就是与POST请求中一样的Content-Type和Content-Length。在本例中,首部Content-Type指定了MIME类型HTML(text/html),其编码类型是ISO-8859-1(这是针对美国英语资源的编码标准)。响应主体所包含的就是所请求资源的HTML源文件(尽管还可能包含纯文本或其他资源类型的二进制数据)。浏览器将把这些数据显示给用户。  
  107.   
  108. 注意,这里并没有指明针对该响应的请求类型,不过这对于服务器并不重要。客户端知道每种类型的请求将返回什么类型的数据,并决定如何使用这些数据。  
  109.   
  110.   
  111. 附录:使用Java套接字实现一个可以处理get和post请求的小HTTP服务器程序  
  112. /** 
  113. * SimpleHttpServer.java 
  114. */  
  115.   
  116. import java.io.*;  
  117. import java.net.*;  
  118. import java.util.StringTokenizer;  
  119.   
  120. /** 
  121. * 一个简单的用 Java Socket 编写的 HTTP 服务器应用, 演示了请求和应答的协议通信内容以及 
  122. * 给客户端返回 HTML 文本和二进制数据文件(一个图片), 同时展示了 404, 200 等状态码. 
  123. * 首先运行这个程序,然后打开Web浏览器,键入http://localhost,则这个程序能够显示出浏览器发送了那些信息 
  124. * 并且向浏览器返回一个网页和一副图片, 并测试同浏览器对话. 
  125. * 当浏览器看到 HTML 中带有图片地址时, 则会发出第二次连接来请求图片等资源. 
  126. * 这个例子可以帮您理解 Java 的 HTTP 服务器软件是基于 J2SE 的 Socket 等软件编写的概念, 并熟悉 
  127. * HTTP 协议. 
  128. * 相反的用 Telnet 连接到已有的服务器则可以帮忙理解浏览器的运行过程和服务器端的返回内容. 
  129. * 
  130. * <pre> 
  131. *       当用户在Web浏览器地址栏中输入一个带有http://前缀的URL并按下Enter后,或者在Web页面中某个以http://开头的超链接上单击鼠标,HTTP事务处理的第一个阶段--建立连接阶段就开始了.HTTP的默认端口是80. 
  132. *    随着连接的建立,HTTP就进入了客户向服务器发送请求的阶段.客户向服务器发送的请求是一个有特定格式的ASCII消息,其语法规则为: 
  133. * < Method > < URL > < HTTP Version > < > 
  134. * { <Header>:<Value> < >}* 
  135. * < > 
  136. * { Entity Body } 
  137. *    请求消息的顶端是请求行,用于指定方法,URL和HTTP协议的版本,请求行的最后是回车换行.方法有GET,POST,HEAD,PUT,DELETE等. 
  138. * 在请求行之后是若干个报头(Header)行.每个报头行都是由一个报头和一个取值构成的二元对,报头和取值之间以":"分隔;报头行的最后是回车换行.常见的报头有Accept(指定MIME媒体类型),Accept_Charset(响应消息的编码方式),Accept_Encoding(响应消息的字符集),User_Agent(用户的浏览器信息)等. 
  139. *    在请求消息的报头行之后是一个回车换行,表明请求消息的报头部分结束.在这个之后是请求消息的消息实体(Entity Body).具体的例子参看httpRequest.txt. 
  140. *     Web服务器在收到客户请求并作出处理之后,要向客户发送应答消息.与请求消息一样,应答消息的语法规则为: 
  141. * < HTTP Version> <Status Code> [<Message>]< > 
  142. * { <Header>:<Value> < > } * 
  143. * < > 
  144. * { Entity Body } 
  145. *    应答消息的第一行为状态行,其中包括了HTTP版本号,状态码和对状态码进行简短解释的消息;状态行的最后是回车换行.状态码由3位数字组成,有5类:  
  146. * 参看:HTTP应答码及其意义  
  147.  
  148. * 1XX 保留  
  149. * 2XX 表示成功  
  150. * 3XX 表示URL已经被移走  
  151. * 4XX 表示客户错误  
  152. * 5XX 表示服务器错误  
  153. * 例如:415,表示不支持改媒体类型;503,表示服务器不能访问.最常见的是200,表示成功.常见的报头有:Last_Modified(最后修改时间),Content_Type(消息内容的MIME类型),Content_Length(内容长度)等. 
  154. *    在报头行之后也是一个回车换行,用以表示应答消息的报头部分的结束,以及应答消息实体的开始. 
  155. *    下面是一个应答消息的例子: 
  156. * HTTP/1.0 200 OK 
  157. * Date: Moday,07-Apr-97 21:13:02 GMT 
  158. * Server:NCSA/1.1 
  159. * MIME_Version:1.0 
  160. * Content_Type:text/html 
  161. * Last_Modified:Thu Dec 5 09:28:01 1996 
  162. * Coentent_Length:3107 
  163.  
  164. * <HTML><HEAD><TITLE></HTML> 
  165.  
  166. * 在用Java语言实现HTTP服务器时,首先启动一个java.net.ServerSocket在提供服务的端口上监听连接.向客户返回文本时,可以用PrintWriter,但是如果返回二进制数据,则必须使用OutputStream.write(byte[])方法,返回的应答消息字符串可以使用String.getBytes()方法转换为字节数组返回,或者使用PrintStream的print()方法写入文本,用write(byte[])方法写入二进制数据. 
  167.  
  168. * </pre> 
  169. * @author 刘长炯 
  170. * @version 1.0 2007-07-24 Sunday 
  171. */  
  172. public class SimpleHttpServer implements Runnable {  
  173.     /** 
  174.      *  
  175.      */  
  176.     ServerSocket serverSocket;//服务器Socket  
  177.       
  178.     /** 
  179.      * 服务器监听端口, 默认为 80. 
  180.      */  
  181.     public static int PORT=80;//标准HTTP端口  
  182.       
  183.     /** 
  184.      * 开始服务器 Socket 线程. 
  185.      */  
  186.     public SimpleHttpServer() {  
  187.         try {  
  188.             serverSocket=new ServerSocket(PORT);  
  189.         } catch(Exception e) {  
  190.             System.out.println("无法启动HTTP服务器:"+e.getLocalizedMessage());  
  191.         }  
  192.         if(serverSocket==null) System.exit(1);//无法开始服务器  
  193.         new Thread(this).start();  
  194.         System.out.println("HTTP服务器正在运行,端口:"+PORT);  
  195.     }  
  196.       
  197.     /** 
  198.      * 运行服务器主线程, 监听客户端请求并返回响应. 
  199.      */  
  200.     public void run() {  
  201.         while(true) {  
  202.             try {  
  203.                 Socket client=null;//客户Socket  
  204.                 client=serverSocket.accept();//客户机(这里是 IE 等浏览器)已经连接到当前服务器  
  205.                 if(client!=null) {  
  206.                     System.out.println("连接到服务器的用户:"+client);  
  207.                     try {  
  208.                         // 第一阶段: 打开输入流  
  209.                         BufferedReader in=new BufferedReader(new InputStreamReader(  
  210.                                 client.getInputStream()));  
  211.                           
  212.                         System.out.println("客户端发送的请求信息: ***************");  
  213.                         // 读取第一行, 请求地址  
  214.                         String line=in.readLine();  
  215.                         System.out.println(line);  
  216.                         String resource=line.substring(line.indexOf('/'),line.lastIndexOf('/')-5);  
  217.                         //获得请求的资源的地址  
  218.                         resource=URLDecoder.decode(resource, "UTF-8");//反编码 URL 地址  
  219.                         String method = new StringTokenizer(line).nextElement().toString();// 获取请求方法, GET 或者 POST  
  220.   
  221.                         // 读取所有浏览器发送过来的请求参数头部信息  
  222.                         while( (line = in.readLine()) != null) {  
  223.                             System.out.println(line);  
  224.                               
  225.                             if(line.equals("")) break;  
  226.                         }  
  227.                           
  228.                         // 显示 POST 表单提交的内容, 这个内容位于请求的主体部分  
  229.                         if("POST".equalsIgnoreCase(method)) {  
  230.                             System.out.println(in.readLine());  
  231.                         }  
  232.                           
  233.                         System.out.println("请求信息结束 ***************");  
  234.                         System.out.println("用户请求的资源是:"+resource);  
  235.                         System.out.println("请求的类型是: " + method);  
  236.   
  237.                         // GIF 图片就读取一个真实的图片数据并返回给客户端  
  238.                         if(resource.endsWith(".gif")) {  
  239.                             fileService("images/test.gif", client);  
  240.                             closeSocket(client);  
  241.                             continue;  
  242.                         }  
  243.                           
  244.                         // 请求 JPG 格式就报错 404  
  245.                         if(resource.endsWith(".jpg")) {  
  246.                                                     PrintWriter out=new PrintWriter(client.getOutputStream(),true);  
  247.                         out.println("HTTP/1.0 404 Not found");//返回应答消息,并结束应答  
  248.                         out.println();// 根据 HTTP 协议, 空行将结束头信息  
  249.                         out.close();  
  250.                         closeSocket(client);  
  251.                         continue;  
  252.                         } else {  
  253.                             // 用 writer 对客户端 socket 输出一段 HTML 代码  
  254.                             PrintWriter out=new PrintWriter(client.getOutputStream(),true);  
  255.                             out.println("HTTP/1.0 200 OK");//返回应答消息,并结束应答  
  256.                             out.println("Content-Type:text/html;charset=GBK");  
  257.                             out.println();// 根据 HTTP 协议, 空行将结束头信息  
  258.   
  259.                             out.println("<h1> Hello Http Server</h1>");  
  260.                             out.println("你好, 这是一个 Java HTTP 服务器 demo 应用.<br>");  
  261.                             out.println("您请求的路径是: " + resource + "<br>");  
  262.                             out.println("这是一个支持虚拟路径的图片:<img src='abc.gif'><br>" +  
  263.                                     "<a href='abc.gif'>点击打开abc.gif, 是个服务器虚拟路径的图片文件.</a>");  
  264.                             out.println("<br>这是个会反馈 404 错误的的图片:<img src='test.jpg'><br><a href='test.jpg'>点击打开test.jpg</a><br>");  
  265.                             out.println("<form method=post action='/'>POST 表单 <input name=username value='用户'> <input name=submit type=submit value=submit></form>");  
  266.                             out.close();  
  267.   
  268.                             closeSocket(client);  
  269.                         }  
  270.                     } catch(Exception e) {  
  271.                         System.out.println("HTTP服务器错误:"+e.getLocalizedMessage());  
  272.                     }  
  273.                 }  
  274.                 //System.out.println(client+"连接到HTTP服务器");//如果加入这一句,服务器响应速度会很慢  
  275.             } catch(Exception e) {  
  276.                 System.out.println("HTTP服务器错误:"+e.getLocalizedMessage());  
  277.             }  
  278.         }  
  279.     }  
  280.       
  281.     /** 
  282.      * 关闭客户端 socket 并打印一条调试信息. 
  283.      * @param socket 客户端 socket. 
  284.      */  
  285.     void closeSocket(Socket socket) {  
  286.         try {  
  287.             socket.close();  
  288.         } catch (IOException ex) {  
  289.             ex.printStackTrace();  
  290.         }  
  291.                             System.out.println(socket + "离开了HTTP服务器");          
  292.     }  
  293.       
  294.     /** 
  295.      * 读取一个文件的内容并返回给浏览器端. 
  296.      * @param fileName 文件名 
  297.      * @param socket 客户端 socket. 
  298.      */  
  299.         void fileService(String fileName, Socket socket)  
  300.     {  
  301.               
  302.         try  
  303.         {  
  304.             PrintStream out = new PrintStream(socket.getOutputStream(), true);  
  305.             File fileToSend = new File(fileName);  
  306.             if(fileToSend.exists() && !fileToSend.isDirectory())  
  307.             {  
  308.                 out.println("HTTP/1.0 200 OK");//返回应答消息,并结束应答  
  309.                 out.println("Content-Type:application/binary");  
  310.                 out.println("Content-Length:" + fileToSend.length());// 返回内容字节数  
  311.                 out.println();// 根据 HTTP 协议, 空行将结束头信息  
  312.                   
  313.                 FileInputStream fis = new FileInputStream(fileToSend);  
  314.                 byte data[] = new byte[fis.available()];  
  315.                 fis.read(data);  
  316.                 out.write(data);  
  317.                 out.close();  
  318.                 fis.close();  
  319.             }  
  320.         }  
  321.         catch(Exception e)  
  322.         {  
  323.             System.out.println("传送文件时出错:" + e.getLocalizedMessage());  
  324.         }  
  325.     }  
  326.       
  327.     /** 
  328.      * 打印用途说明. 
  329.      */  
  330.     private static void usage() {  
  331.         System.out.println("Usage: java HTTPServer <port> Default port is 80.");  
  332.     }  
  333.       
  334.       
  335.     /** 
  336.      * 启动简易 HTTP 服务器 
  337.      * @param args  
  338.      */  
  339.     public static void main(String[] args) {  
  340.         try {  
  341.             if(args.length != 1) {  
  342.                 usage();  
  343.             } else if(args.length == 1) {  
  344.                 PORT = Integer.parseInt(args[0]);  
  345.             }  
  346.         } catch (Exception ex) {  
  347.             System.err.println("Invalid port arguments. It must be a integer that greater than 0");  
  348.         }  
  349.           
  350.         new SimpleHttpServer();  
  351.     }  
  352.       
  353. }  
  354.   
  355. </HTML>  
  356. *   
  357. * 在用Java语言实现HTTP服务器时,首先启动一个java.net.ServerSocket在提供服务的端口上监听连接.向客户返回文本时,可以用PrintWriter,但是如果返回二进制数据,则必须使用OutputStream.write(byte[])方法,返回的应答消息字符串可以使用String.getBytes()方法转换为字节数组返回,或者使用PrintStream的print()方法写入文本,用write(byte[])方法写入二进制数据.  
  358. *   
  359. * </pre>  
  360. @author 刘长炯  
  361. @version 1.0 2007-07-24 Sunday  
  362. */  
  363. public class SimpleHttpServer implements Runnable {  
  364.     /** 
  365.      *  
  366.      */  
  367.     ServerSocket serverSocket;//服务器Socket  
  368.       
  369.     /** 
  370.      * 服务器监听端口, 默认为 80. 
  371.      */  
  372.     public static int PORT=80;//标准HTTP端口  
  373.       
  374.     /** 
  375.      * 开始服务器 Socket 线程. 
  376.      */  
  377.     public SimpleHttpServer() {  
  378.         try {  
  379.             serverSocket=new ServerSocket(PORT);  
  380.         } catch(Exception e) {  
  381.             System.out.println("无法启动HTTP服务器:"+e.getLocalizedMessage());  
  382.         }  
  383.         if(serverSocket==null) System.exit(1);//无法开始服务器  
  384.         new Thread(this).start();  
  385.         System.out.println("HTTP服务器正在运行,端口:"+PORT);  
  386.     }  
  387.       
  388.     /** 
  389.      * 运行服务器主线程, 监听客户端请求并返回响应. 
  390.      */  
  391.     public void run() {  
  392.         while(true) {  
  393.             try {  
  394.                 Socket client=null;//客户Socket  
  395.                 client=serverSocket.accept();//客户机(这里是 IE 等浏览器)已经连接到当前服务器  
  396.                 if(client!=null) {  
  397.                     System.out.println("连接到服务器的用户:"+client);  
  398.                     try {  
  399.                         // 第一阶段: 打开输入流  
  400.                         BufferedReader in=new BufferedReader(new InputStreamReader(  
  401.                                 client.getInputStream()));  
  402.                           
  403.                         System.out.println("客户端发送的请求信息: ***************");  
  404.                         // 读取第一行, 请求地址  
  405.                         String line=in.readLine();  
  406.                         System.out.println(line);  
  407.                         String resource=line.substring(line.indexOf('/'),line.lastIndexOf('/')-5);  
  408.                         //获得请求的资源的地址  
  409.                         resource=URLDecoder.decode(resource, "UTF-8");//反编码 URL 地址  
  410.                         String method = new StringTokenizer(line).nextElement().toString();// 获取请求方法, GET 或者 POST  
  411.   
  412.                         // 读取所有浏览器发送过来的请求参数头部信息  
  413.                         while( (line = in.readLine()) != null) {  
  414.                             System.out.println(line);  
  415.                               
  416.                             if(line.equals("")) break;  
  417.                         }  
  418.                           
  419.                         // 显示 POST 表单提交的内容, 这个内容位于请求的主体部分  
  420.                         if("POST".equalsIgnoreCase(method)) {  
  421.                             System.out.println(in.readLine());  
  422.                         }  
  423.                           
  424.                         System.out.println("请求信息结束 ***************");  
  425.                         System.out.println("用户请求的资源是:"+resource);  
  426.                         System.out.println("请求的类型是: " + method);  
  427.   
  428.                         // GIF 图片就读取一个真实的图片数据并返回给客户端  
  429.                         if(resource.endsWith(".gif")) {  
  430.                             fileService("images/test.gif", client);  
  431.                             closeSocket(client);  
  432.                             continue;  
  433.                         }  
  434.                           
  435.                         // 请求 JPG 格式就报错 404  
  436.                         if(resource.endsWith(".jpg")) {  
  437.                                                     PrintWriter out=new PrintWriter(client.getOutputStream(),true);  
  438.                         out.println("HTTP/1.0 404 Not found");//返回应答消息,并结束应答  
  439.                         out.println();// 根据 HTTP 协议, 空行将结束头信息  
  440.                         out.close();  
  441.                         closeSocket(client);  
  442.                         continue;  
  443.                         } else {  
  444.                             // 用 writer 对客户端 socket 输出一段 HTML 代码  
  445.                             PrintWriter out=new PrintWriter(client.getOutputStream(),true);  
  446.                             out.println("HTTP/1.0 200 OK");//返回应答消息,并结束应答  
  447.                             out.println("Content-Type:text/html;charset=GBK");  
  448.                             out.println();// 根据 HTTP 协议, 空行将结束头信息  
  449.   
  450.                             out.println("<h1> Hello Http Server</h1>");  
  451.                             out.println("你好, 这是一个 Java HTTP 服务器 demo 应用.<br>");  
  452.                             out.println("您请求的路径是: " + resource + "<br>");  
  453.                             out.println("这是一个支持虚拟路径的图片:<img src="abc.gif" mce_src="abc.gif"><br>" +  
  454.                                     "<a href="abc.gif" mce_href="abc.gif">点击打开abc.gif, 是个服务器虚拟路径的图片文件.</a>");  
  455.                             out.println("<br>这是个会反馈 404 错误的的图片:<img src="test.jpg" mce_src="test.jpg"><br><a href="test.jpg" mce_href="test.jpg">点击打开test.jpg</a><br>");  
  456.                             out.println("<form method=post action='/'>POST 表单 <input name=username value='用户'> <input name=submit type=submit value=submit></form>");  
  457.                             out.close();  
  458.   
  459.                             closeSocket(client);  
  460.                         }  
  461.                     } catch(Exception e) {  
  462.                         System.out.println("HTTP服务器错误:"+e.getLocalizedMessage());  
  463.                     }  
  464.                 }  
  465.                 //System.out.println(client+"连接到HTTP服务器");//如果加入这一句,服务器响应速度会很慢  
  466.             } catch(Exception e) {  
  467.                 System.out.println("HTTP服务器错误:"+e.getLocalizedMessage());  
  468.             }  
  469.         }  
  470.     }  
  471.       
  472.     /** 
  473.      * 关闭客户端 socket 并打印一条调试信息. 
  474.      * @param socket 客户端 socket. 
  475.      */  
  476.     void closeSocket(Socket socket) {  
  477.         try {  
  478.             socket.close();  
  479.         } catch (IOException ex) {  
  480.             ex.printStackTrace();  
  481.         }  
  482.                             System.out.println(socket + "离开了HTTP服务器");          
  483.     }  
  484.       
  485.     /** 
  486.      * 读取一个文件的内容并返回给浏览器端. 
  487.      * @param fileName 文件名 
  488.      * @param socket 客户端 socket. 
  489.      */  
  490.         void fileService(String fileName, Socket socket)  
  491.     {  
  492.               
  493.         try  
  494.         {  
  495.             PrintStream out = new PrintStream(socket.getOutputStream(), true);  
  496.             File fileToSend = new File(fileName);  
  497.             if(fileToSend.exists() && !fileToSend.isDirectory())  
  498.             {  
  499.                 out.println("HTTP/1.0 200 OK");//返回应答消息,并结束应答  
  500.                 out.println("Content-Type:application/binary");  
  501.                 out.println("Content-Length:" + fileToSend.length());// 返回内容字节数  
  502.                 out.println();// 根据 HTTP 协议, 空行将结束头信息  
  503.                   
  504.                 FileInputStream fis = new FileInputStream(fileToSend);  
  505.                 byte data[] = new byte[fis.available()];  
  506.                 fis.read(data);  
  507.                 out.write(data);  
  508.                 out.close();  
  509.                 fis.close();  
  510.             }  
  511.         }  
  512.         catch(Exception e)  
  513.         {  
  514.             System.out.println("传送文件时出错:" + e.getLocalizedMessage());  
  515.         }  
  516.     }  
  517.       
  518.     /** 
  519.      * 打印用途说明. 
  520.      */  
  521.     private static void usage() {  
  522.         System.out.println("Usage: java HTTPServer <port> Default port is 80.");  
  523.     }  
  524.       
  525.       
  526.     /** 
  527.      * 启动简易 HTTP 服务器 
  528.      * @param args  
  529.      */  
  530.     public static void main(String[] args) {  
  531.         try {  
  532.             if(args.length != 1) {  
  533.                 usage();  
  534.             } else if(args.length == 1) {  
  535.                 PORT = Integer.parseInt(args[0]);  
  536.             }  
  537.         } catch (Exception ex) {  
  538.             System.err.println("Invalid port arguments. It must be a integer that greater than 0");  
  539.         }  
  540.           
  541.         new SimpleHttpServer();  
  542.     }  
  543.       
  544. }  

相关文章推荐

http协议的PDF文档

  • 2016-10-08 21:00
  • 1023KB
  • 下载

HTTP2.0协议

  • 2015-12-15 18:14
  • 1.12MB
  • 下载

HTTP协议全览

来源:http://blog.csdn.net/u014766136/article/details/51801353 目录(?)[-] 1 HTTP URL2 H...

http协议详解

  • 2015-07-01 16:50
  • 29KB
  • 下载

http协议

  • 2015-01-13 10:25
  • 205KB
  • 下载

Java Web---HTTP应用层协议

一、网络通讯1.计算机间通讯的要素:(1)IP地址:主机标识 (2)端口:数据的出入口,对外提供服务就是对外暴露端口。网络应用软件其实就是在处理指定端口的数据。 (3)协议:通讯的规则。TCP传输...

http协议文档啊

  • 2014-11-26 21:13
  • 36.03MB
  • 下载

http协议文档啊2

  • 2014-11-26 21:16
  • 45MB
  • 下载

HTTP协议详解

引言                        ...

HTTP协议详解

  • 2015-07-07 18:40
  • 205KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)