开发属于自己的Web服务器

本文基于.net core 的控制台程序作为服务端

main函数：

 class Program
     {
         static void Main(string[] args)
         {
             Console.WriteLine("The server is starting......");
 
             new Server().StartServer();
 
             Console.ReadLine();
         }
     }

其中核心代码在Server这个类上面：

 public class Server
     {
         private Socket socketWatch = null;
         private Thread threadWatch = null;
         private string ipAddress = "127.0.0.1";
         private string port = "";
 
         public Server()
         {
             socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
             socketWatch.Bind(new IPEndPoint(IPAddress.Parse(ipAddress), int.Parse(port)));
             socketWatch.Listen();
             // 创建Thread->后台执行
             threadWatch = new Thread(ListenClientConnect);
             threadWatch.IsBackground = true;
         }
 
         public void StartServer()
         {
             threadWatch.Start(socketWatch);
         }
 
         private void ListenClientConnect(object objSocket)
         {
             Socket socketListen = objSocket as Socket;
 
             while (true)
             {
                 Socket proxSocket = socketListen.Accept();
                 byte[] data = new byte[ *  * ];
                 int length = proxSocket.Receive(data, , data.Length, SocketFlags.None);
                 // Step1:接收HTTP请求
                 string requestText = Encoding.Default.GetString(data, , length);
                 HttpContext context = new HttpContext(requestText);
                 // Step2:处理HTTP请求
                 HttpApplication application = new HttpApplication();
                 application.ProcessRequest(context);
                 // Step3:响应HTTP请求
                 Console.WriteLine(string.Format("{0} {1} from {2}", context.Request.HttpMethod, context.Request.Url, proxSocket.RemoteEndPoint.ToString()));
                 proxSocket.Send(context.Response.GetResponseHeader());
                 proxSocket.Send(context.Response.Body);
                 // Step4:即时关闭Socket连接
                 proxSocket.Shutdown(SocketShutdown.Both);
                 proxSocket.Close();
             }
         }
     }

上面代码中，主要是基于Socket和线程。在构造函数中初始化了服务器端Socket，还初始化了Thread，并且设置为后台线程。ListenClientConnect函数主要做的事情是接受浏览器请求，并且转化为HttpContext和HttpApplication，最后输出响应并且关闭socket。

这里面有几个比较重要的类，主要如下：

 public class HttpContext
     {
         public HttpRequest Request { get; set; }
         public HttpResponse Response { get; set; }
 
         public HttpContext(string requestText)
         {
             Request = new HttpRequest(requestText);
             Response = new HttpResponse();
         }
     }

HttpContext模拟asp的HttpContext，里面有两个看起来很熟悉的类，HttpRequest和HttpResponse

 public class HttpRequest
     {
         public HttpRequest(string requestText)
         {
             string[] lines = requestText.Replace("\r\n", "\r").Split('\r');
             string[] requestLines = lines[].Split(' ');
             // 获取HTTP请求方式、请求的URL地址、HTTP协议版本
             if(requestLines.Length >= )
             {
                 HttpMethod = requestLines[];
                 Url = requestLines[];
                 HttpVersion = requestLines[];
             }
         }
         // 请求方式：GET or POST?
         public string HttpMethod { get; set; }
         // 请求URL
         public string Url { get; set; }
         // Http协议版本
         public string HttpVersion { get; set; }
         // 请求头
         public Dictionary<string, string> HeaderDictionary { get; set; }
         // 请求体
         public Dictionary<string, string> BodyDictionary { get; set; }
     }

 public class HttpResponse
     {
         // 响应状态码
         public string StateCode { get; set; }
         // 响应状态描述
         public string StateDescription { get; set; }
         // 响应内容类型
         public string ContentType { get; set; }
         //响应报文的正文内容
         public byte[] Body { get; set; }
 
         // 生成响应头信息
         public byte[] GetResponseHeader()
         {
             string strRequestHeader = string.Format(@"HTTP/1.1 {0} {1}
 Content-Type: {2}
 Accept-Ranges: bytes
 Server: Microsoft-IIS/7.5
 X-Powered-By: ASP.NET
 Date: {3}
 Content-Length: {4}
 
 ", StateCode, StateDescription, ContentType, string.Format("{0:R}", DateTime.Now), Body.Length);
 
             return Encoding.UTF8.GetBytes(strRequestHeader);
         }
     }

这两个核心类是关于请求和响应的。

IHttpHandler是另外一个很熟悉的接口，一般处理程序中都会实例化它

 public interface IHttpHandler
     {
         void ProcessRequest(HttpContext context);
     }

我们处理请求的时候就是依靠实例化这个接口了，在我们的实例上面就是HttpApplication

 public class HttpApplication : IHttpHandler
     {
         // 对请求上下文进行处理
         public void ProcessRequest(HttpContext context)
         {
             // 1.获取网站根路径
             if(string.IsNullOrEmpty(context.Request.Url))
             {
                 return;
             }
             string bastPath = AppDomain.CurrentDomain.BaseDirectory;
             string fileName = Path.Combine(bastPath, "LZZWebSite", context.Request.Url.TrimStart('/'));
             string fileExtension = Path.GetExtension(context.Request.Url);
             // 2.处理动态文件请求
             if (fileExtension.Equals(".aspx") || fileExtension.Equals(".ashx"))
             {
                 string className = Path.GetFileNameWithoutExtension(context.Request.Url);
                 IHttpHandler handler = Assembly.GetExecutingAssembly().CreateInstance($"lzzWebServerDemo.Page.{className}", true) as IHttpHandler;
                 handler.ProcessRequest(context);
                 return;
             }
             // 3.处理静态文件请求
             if (!File.Exists(fileName))
             {
                 context.Response.StateCode = "";
                 context.Response.StateDescription = "Not Found";
                 context.Response.ContentType = "text/html";
                 string notExistHtml = Path.Combine(bastPath, @"LZZWebSite\notfound.html");
                 context.Response.Body = File.ReadAllBytes(notExistHtml);
             }
             else
             {
                 context.Response.StateCode = "";
                 context.Response.StateDescription = "OK";
                 context.Response.ContentType = GetContenType(Path.GetExtension(context.Request.Url));
                 context.Response.Body = File.ReadAllBytes(fileName);
             }
         }
 
         // 根据文件扩展名获取内容类型
         public string GetContenType(string fileExtension)
         {
             string type = "text/html; charset=UTF-8";
             switch (fileExtension)
             {
                 case ".aspx":
                 case ".html":
                 case ".htm":
                     type = "text/html; charset=UTF-8";
                     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; charset=gbk";
                     break;
             }
             return type;
         }

上面的业务比较清晰，如果是静态资源，就直接响应返回。如果是动态资源，例如aspx、ashx的话就通过反射实例化对应的处理类。我们例子上是这样模拟的：

 public class LzzPage: IHttpHandler
     {
         public void ProcessRequest(HttpContext context)
         {
             StringBuilder sbText = new StringBuilder();
             sbText.Append("<html>");
             sbText.Append("<head></head>");
             sbText.Append("<body>");
             sbText.Append("<h1>demo</h1>");
             sbText.Append("lzzdemolzzdemo");
             sbText.Append(string.Format("<h3>time：{0}</h3>", DateTime.Now.ToString()));
             sbText.Append("</body>");
             sbText.Append("</html>");
             context.Response.Body = Encoding.UTF8.GetBytes(sbText.ToString());
             context.Response.StateCode = "";
             context.Response.ContentType = "text/html";
             context.Response.StateDescription = "OK";
         }
     }

最后来一张整个体统的结构图

运行图：