Code666 (代码贴、代码片段)

[Java] Java实现http协议解析 →→→→→进入此内容的聊天室

来自 , 2020-06-01, 写在 Java, 查看 127 次.
URL http://www.code666.cn/view/a7d8ae45
  1.  　　下面的代码片断创建一个与本地HTTP服务器（127.0.0.1代表本地主机的IP地址）通信的Socket，发送一个HTTP请求包，准备接收服务器的应答。
  2.   Socket socket    = new Socket("127.0.0.1", "80");
  3.   OutputStream os  = socket.getOutputStream();
  4.   InputStream  ins = socket.getInputStream();
  6.   sb.append("GET /index.jsp HTTP/1.1\r\n");//注意\r\n为回车换行
  7.   sb.append("Accept-Language: zh-cn\r\n");
  8.   sb.append("Connection: Keep-Alive\r\n");
  9.   sb.append("Host: 192.168.0.106\r\n");
  10.   sb.append("Content-Length: 37\r\n");
  11.   sb.append("\r\n");
  12.   sb.append("userName=new_andy&password=new_andy\r\n");
  13.   sb.append("\r\n");
  14.  
  15.   //向Web服务器发送一个HTTP请求包
  16.   os.write(sb.toString().getBytes());
  17.  
  18.   服务器端的代码在大致结构为：
  19.   while (!shutdown) {
  20.         Socket socket = null;
  21.         try {
  22.             socket = serverSocket.accept(); //等待客户以送HTTP请求包
  23.             // 创建HTTP请求包处理线程
  24.             RequestThread request = new RequestThread(socket);
  25.             request.start();
  26.             if(shutdown) System.exit(0);
  27.         }
  28.         catch (Exception e) {
  29.             e.printStackTrace();
  30.         }
  31.     }
  32.   RequestThread线程分析HTTP请求包，跟根据请求包内容在服务端生成一个HTTP应答包。下一节说明怎样分析HTTP包。
  33.   InputStream  input = socket.getInputStream();  //从此字节数据流获得HTTP请求包内容
  34.     OutputStream output= socket.getOutputStream(); //向此字节流写入HTTP应答包内容
  35.    
  36. 三、读取HTTP包
  37.   以下我自己设计的一个读取HTTP包的类SocketRequest。
  38.   public class SocketRequest {  //从指定的Socket的InputStream中读取数据
  39.   private InputStream  input;
  40.   private String     uri;
  41.   private StringBuffer  request=new StringBuffer();  //用于保存所有内容
  42.   private int       CONTENT_LENGTH=0;  //实际包内容数据长
  43.   private boolean    bePost = false;
  44.   private boolean    beHttpResponse = false;
  45.   private boolean    beChucked = false;
  46.   private boolean    beGet = false;
  47.   private byte       crlf13 = (byte)13; //碶 ?br/>   private byte       crlf10 = (byte)10;  //碶 ?/FONT>
  48.   public SocketRequest(InputStream input) {
  49.     this.input = input;
  50.   }
  51.  public SocketRequest(Socket socket) {
  52.     this.input = socket.getInputStream();
  53.   }
  54.   public void ReadData() {  //解析 获得InputStream的数据
  55.  
  56.   ReadHeader();  //头部
  57.   if(beChucked) //为Chucked
  58.   {
  59.    int ChuckSize=0;
  60.    while((ChuckSize=getChuckSize())>0) //多个Chucked
  61.    {
  62.     readLenData(ChuckSize+2);//读取定长数据
  63.    }
  64.    readLenData(2); //最后的2位
  65.   }
  66.  
  67.   if(CONTENT_LENGTH>0)
  68.   {
  69.    readLenData(CONTENT_LENGTH);//读取定长数据
  70.   }
  71.  
  72.     uri = "";//parseUri(new String(request));
  73.   }
  74.  
  75.   private void readLenData(int size)  //读取定长数据
  76.   {
  77.    int readed=0;  //已经读取数
  78.    try{
  79.     int available=0;//input.available(); //可读数
  80.     if(available>(size-readed)) available=size-readed;
  81.     while( readed<size )
  82.      {
  83.        while(available==0){  //等到有数据可读
  84.          available = input.available(); //可读数
  85.         }
  86.         if(available>(size-readed)) available= size-readed; //size-readed--剩余数
  87.         if(available>2048) available= 2048; //size-readed--剩余数
  88.        byte[] buffer = new byte[available];
  89.        int reading = input.read(buffer);
  90.        request=request.append(new String(buffer,0,reading));  //byte数组相加
  91.         readed+=reading;  //已读字符
  92.    }
  93.    }catch(IOException e){
  94.      System.out.println("Read readLenData Error!");
  95.    }
  96.  }
  97.  
  98.    private void  ReadHeader() //读取头部 并获得大小
  99.    {
  100.     byte[]  crlf   = new byte[1];
  101.    int     crlfNum= 0;   //已经连接的回车换行数 crlfNum=4为头部结束
  102.     try{
  103.      while( input.read(crlf)!=-1 )   //读取头部
  104.      {
  105.       if(crlf[0]==crlf13 || crlf[0]==crlf10)
  106.       {
  107.          crlfNum++;
  108.       }
  109.       else
  110.       {  crlfNum=0;  } //不是则清
  111.       request=request.append(new String(crlf,0,1));  //byte数组相加
  112.       if(crlfNum==4) break;
  113.      }
  114.    }catch(IOException e){
  115.      System.out.println("Read Http Header Error!");
  116.      return;
  117.     }
  118.  
  119.     String tempStr=(new String(request)).toUpperCase();
  120.    
  121.     //这里我只处理了GET与POST方法
  122.     String  strMethod  = tempStr.substring(0,4);
  123.     if(strMethod.equals("GET ")) //前
  124.     {  beGet=true;    
  125.     }
  126.     else if(strMethod.equals("POST"))
  127.     {
  128.      bePost=true;
  129.      getContentlen_Chucked(tempStr);
  130.     }
  131.     else {
  132.      System.out.println("不支持的HTTP包类型");
  133.      
  134.     } //其它的其它类型 暂不支持
  135.   }
  136.   private void getContentlen_Chucked(String tempStr)  //获得长度 CONTENT-LENGTH 或 是否为CHUNKED型
  137.   {
  138.    String ss1="CONTENT-LENGTH:";
  139.    String ss2=new String("TRANSFER-ENCODING: CHUNKED");
  140.    
  141.    int clIndex   = tempStr.indexOf(ss1);
  142.     int chuckIndex = tempStr.indexOf(ss2);  //为CHUNKED型
  143.     byte requst[]= tempStr.getBytes();
  144.     if(clIndex!=-1)
  145.     { //从clIndex+1起至\r\n
  146.        StringBuffer sb=new StringBuffer();
  147.        
  148.        for(int i=(clIndex+16);;i++)
  149.        {
  150.         if(requst[i]!=(byte)13 && requst[i]!=(byte)10 )
  151.         {
  152.           sb.append((char)requst[i]);
  153.         }
  154.         else
  155.          break;
  156.        }
  157.        
  158.        CONTENT_LENGTH=Integer.parseInt(sb.toString());  //正式的HTML文件的大小
  159.        //System.out.println("CONTENT_LENGTH==  "+CONTENT_LENGTH);
  160.    }
  161.    if(chuckIndex!=-1) beChucked=true;
  162.   }
  163.    
  164.   private int  getChuckSize() //Chuck大小
  165.    {
  166.     byte[]  crlf   = new byte[1];
  167.     StringBuffer  sb1   = new StringBuffer();
  168.     int     crlfNum= 0;   //已经连接的回车换行数 crlfNum=4为头部结束
  169.    
  170.     try{
  171.      while(input.read(crlf)!=-1)   //读取头部
  172.      {
  173.       if(crlf[0]==crlf13 || crlf[0]==crlf10)
  174.       {  crlfNum++; }
  175.       else
  176.       {  crlfNum=0;  } //不是则清
  177.       sb1.append((char)crlf[0]);
  178.       request=request.append(new String(crlf,0,1));  //byte数组相加
  179.       if(crlfNum==2) break;
  180.      }
  181.    }catch(IOException e){
  182.      System.out.println("Read Http Package Error!");
  183.      return 0;
  184.     }
  185.  
  186.    return Integer.parseInt((sb1.toString()).trim(),16); //16进控制
  187.  }
  188.   //通过此来进行过滤，是否为发至目标服务器的HTTP包
  189.   private String parseUri(String requestString) {
  190.     int index1, index2;
  191.     index1 = requestString.indexOf(??;
  192.     if (index1 != -1) {
  193.       index2 = requestString.indexOf(?? index1 + 1);
  194.       if (index2 > index1)
  195.         return requestString.substring(index1 + 1, index2);
  196.     }
  197.     return null;
  198.   }
  199.   public String getData() {
  200.     return request.toString();
  201.   }
  202. }
  203.  使用此类:
  204.  SocketRequest request = new SocketRequest(socket); //socket为ServerSocket.accept()返回的Socket实例
  205.  request.ReadData();  //读取数据
  206.  request.getData();
  207.  为什么我要用这么大的力量去读取呢，尤其是在因为Socket连接在发送数据时，由于网络的原因经常会发生延迟现象，可能在服务器端开始接收数据时可能只有部分数据可以从InputStream中获得，在一些地方处理不当时，可能只能获得不完整的数据或是错误的数据。
  208.  从InputStream读取字节时有多种办法:
  209.  常用int read()与int read(byte[] b)。在用read(byte[])时，程序员经常会犯错误，因为在网络环境中，读取的数据量不一定等于参数的大小。
  210.  
  211.  希望我的这篇文章能给你带来一些帮助。//源代码片段来自云代码http://yuncode.net
  212.                        

回复 "Java实现http协议解析"

这儿你可以回复上面这条便签

captcha

贴代码片段 - Code666