多线程-------（1）对http协议的理解以及IIS的内部原理

 

一、Http协议是一个应用层的协议，有响应和请求构成，Http协议是一个无状态的协议。

二、http协议请求报文是由 请求行  请求头部  请求体组成。

1、请求行 ：GET /images/logo.gif HTTP/1.1

典型的http请求报文：

l HTTP Command: //方法字段，说明其使用的是GET 方法

l URI: / //URL 字段，发送请求至保存该网站的服务器。

l HTTP Version: //http 协议版本字段，用是的http/1.1 版本

l Accept: //指示可被接受的请求回应的介质类型范围列表。

l Accept-Language: //限制了请求回应中首选的语言为简体中文，否则使用默认值。

l Accept-Encoding: //限制了回应中可接受的内容编码值,指示附加内容解码方式为gzip,deflate.

l User-Agent: //定义用户代理，即发送请求的浏览器类型为Mozilla/4.0

l Host: www.XX.com\r\n //定义了目标所在的主机

l Connection: Keep-Alive\r\n //告诉服务器使用持久连接

    ⑴请求方法为：get方法。（还可以是post方法等）

    ⑵表示从/images目录下请求logo.gif这个文件。此路径是相对路径。也就是应用程序下，根目录下的images/logo.gif HTTP/1.1文件

    ⑶Host头域 指定请求资源的Intenet主机和端口号，必须表示请求url的原始服务器或网关的位置。

        HTTP/1.1请求必须包含主机头域，否则系统会以400状态码返回。

三、http响应报文是由 响应行 响应头部 响应体组成。

l HTTP Version: HTTP/1.1 //服务器用的是HTTP/1.1 版本

l HTTP Status: 200 //请求成功，信息可以读取，包含在响应的报文中

l Date: //指服务器从文件系统中检索到该对象，插入到响应报文，并发送该响应报文的时间

l Server: //表明刻报文是由一个Apache/2.0.52 的服务器产生的

l X-Powered-By: //表明是使用PHP（版本）的动态网页

l Set- cookie: //

l Vary: //

l Content-Length: //表明实体的长度

l Connection: //告诉客户机在报文发送完毕后仍然保持连接

l Content-Type: //表明实体中的对象是html 文档

l Binary Data: //二进制数据

说明：在服务器给的回应请求中，我们可以从状态码中看到访问的相关信息。状态码表示响应类型，常用的有：

l 1×× 保留

l 2×× 表示请求成功地接收

l 3×× 为完成请求客户需进一步细化请求

l 4×× 客户错误

l 5×× 服务器错误

四、IIS内部原理

public int ServerScoket { get; set; }
        private void btnStart_Click(object sender, EventArgs e)
        {
            IPAddress ipAddress = IPAddress.Parse(this.txtIP.Text);
            IPEndPoint endpoint = new IPEndPoint(ipAddress, int.Parse(this.txtPort.Text));
            Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            socket.Bind(endpoint);
            socket.Listen(10);
            this.lbStatus.Text = "启动";
            this.lbStatus.ForeColor = Color.Green;
            //开始socket的接受请求
            ThreadPool.QueueUserWorkItem(a =>
                {
                    //线程池默认都是后台线程
                    Socket serverSocket = (Socket)a;
                    while (true)
                    {
                        //获取到跟浏览器交互的代理socket
                       var proxSocket= serverSocket.Accept();
                        
                       ThreadPool.QueueUserWorkItem(s => 
                       {
                           Socket pSocket = (Socket)s;
                           byte[] bytes = new byte[1024 * 1024];
                           int realLength = pSocket.Receive(bytes);
                           //把当前的报文封装到了strRequest里面去了
                           string strRequest = Encoding.UTF8.GetString(bytes, 0, realLength);
                           //处理当前的报文，解析当前报文，看看请求是哪个文件，
                           //把请求的文件封装成相应的报文，通过socket发送给浏览器
                           ProcessRequest(strRequest, pSocket);
                       }, proxSocket);
                    }
                },socket);
        }
        //处理客户端的请求
        private void ProcessRequest(string strRequest, Socket pSocket)
        {
            //把请求行取出来
            //初始化请求信息和响应信息实例
            HttpContext context = new HttpContext(strRequest);
            HttpApplication application = new HttpApplication();

            //这时候，请求的响应已经做好了
            //正在处理HTTP请求
            application.ProcessRequest(context);

            //context response
            pSocket.Send(context.Response.GetHeader());
            pSocket.Send(context.Response.BodyData);
            pSocket.Shutdown(SocketShutdown.Both);
            pSocket.Close();
        }

 

public   class HttpContext
    {
      //设置请求
      public HttpRequest Request { get; set; }
      //响应的实例
      public HttpResponse Response { get; set; }
      //构造函数
      public HttpContext(string httpRequestStr)
      {
          Request = new HttpRequest(httpRequestStr);
          Response = new HttpResponse(Request);
      }
    }

/// <summary>
    /// 封装请求报文的信息
    /// </summary>
  public  class HttpRequest
    {
        /*
         GET /login.aspx HTTP/1.1
        Accept: text/html, application/xhtml+xml, #1#*
        Accept-Language: zh-CN
        User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; QDesk 2.3.1185.202; Windows NT 6.1; Trident/5.0)
        Accept-Encoding: gzip, deflate
        Host: localhost:38888
        Connection: Keep-Alive*/

      //将报文传进来
      public HttpRequest(string requestStr)
      {
          if(!string.IsNullOrEmpty(requestStr))
          {
            string[] lines=requestStr.Replace("\r\n","\r").Split('\r');
              //处理请求的Method
            this.Method = lines[0].Split(' ')[0];
              //设置请求的URL 地址
            this.RequestURL = lines[0].Split(' ')[1];
          }
      }
      //是Get 还是set
      public string  Method { get; set; }
      public string  RequestURL { get; set; }
    }

public class HttpResponse
    {
       //请求文件的后缀
       private string _requestFileExt;
       public HttpResponse(HttpRequest request)
       {
           _requestFileExt = Path.GetExtension(request.RequestURL);
       }
       //获取相应提报文字节数组
       public byte[] BodyData { get; set; }
       //获取响应头部
       public byte[] GetHeader()
       {
           StringBuilder sb = new StringBuilder();
           sb.AppendFormat("HTTP/1.1 200 OK\r\n");
           sb.AppendFormat("Content-Type: {0} \r\n", GetContentType(_requestFileExt));
           return Encoding.UTF8.GetBytes(sb.ToString());
       }

       public string GetContentType(string _requestFileExt)
       {
           string type = "text/html";
           switch (_requestFileExt)
           {
               case ".aspx":
                   case ".html":
                case ".htm":
                    type = "text/html";
                    break;
                case ".png":
                    type = "image/png";
                    break;
                case ".gif":
                    type = "image/gif";
                    break;
                case ".jpg":
                case ".jpeg":
                    type = "image/jpeg";
                    break;
                case ".css":
                    type = "text/css";
                    break;
                case ".js":
                    type = "application/x-javascript";
                    break;
                default:
                    type = "text/plain";
                    break;
           }
           return type;
       }

       //返回响应主体
       public byte[] GetBodyData()
       {
           return BodyData;
       }
    }

public  class HttpApplication
    { public void ProcessRequest(HttpContext context)
       {
           string ext = Path.GetExtension(context.Request.RequestURL);
           switch (ext)
           {
               case ".jpg":
               case ".jpeg":
               case ".html":
               case ".htm":
               case ".css":
               case ".js":
                   ProcessStaticFile(context); break;
               case ".aspx":
                   ProcessDynamicFile(context);
                   break;
               default:
                   ProcessStaticFile(context);
                   break;
           }
       }
       //处理动态页面
       public void ProcessDynamicFile(HttpContext context)
       {
           //假设请求Index.aspx
           string className=Path.GetFileNameWithoutExtension(context.Request.RequestURL);
           //获取命名空间
           string nameSpace = System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Namespace;
           //_02HeimaIIS.IndexPage
           string fullName = nameSpace + "." + className;
           //用接口接受不同的实例
           IHttpHandler obj=(IHttpHandler)System.Reflection.Assembly.GetExecutingAssembly().CreateInstance(fullName,true);
           if (obj == null)
           {

           }
           else
           {
               obj.ProcessRequest(context);
           }
       }
       //处理静态页面
       public void ProcessStaticFile(HttpContext context)
       {
           string currentWebDir = AppDomain.CurrentDomain.BaseDirectory;
           string fileName=Path.Combine(currentWebDir,context.Request.RequestURL.TrimStart('/'));
           context.Response.BodyData = File.ReadAllBytes(fileName);
       }
    }

如果是静态网页直接返回，如果是动态页面通过反射实现，以上就是面向接口编程

public class MyPage : IHttpHandler
    {
        public void ProcessRequest(HttpContext context)
        {
            //可以访问数据库，就是动态的
            string strBody = @"<html><head></head><body><h2> big shit y</h2></body></html>";
            context.Response.BodyData = Encoding.UTF8.GetBytes(strBody);
        }      
    }

 

 

 IIS内部处理的文字总结：

 设置一个监听队列，用一个应用程序池中的实例socket A，接受浏览器发送的数据，再从应用程序池中获取一个实例 socket B将接受到的数据进行处理，而 socket A 不断接受浏览器的请求。

socket B处理数据（用到HttpContext HttpApplication MyPage IHandler）

HttpContext

　　HttpRequest 获取请求的方法 及请求的地址

　　HttpResponse得到响应体和 响应头

HttpApplication

　　根据后缀名判断是动态网页还是静态网页

　　动态网页：通过反射获取命名空间  通过请求地址找到类名  通过反射获取实例转化成接口，调用其方法。

处理完成后，由代理socket发送报文头和报文体