开发属于自己的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 = "11111";

        public Server()
        {
            socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            socketWatch.Bind(new IPEndPoint(IPAddress.Parse(ipAddress), int.Parse(port)));
            socketWatch.Listen(100);
            // 创建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[1024 * 1024 * 2];
                int length = proxSocket.Receive(data, 0, data.Length, SocketFlags.None);
                // Step1:接收HTTP请求
                string requestText = Encoding.Default.GetString(data, 0, 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("
", "
").Split('
');
            string[] requestLines = lines[0].Split(' ');
            // 获取HTTP请求方式、请求的URL地址、HTTP协议版本
            if(requestLines.Length >= 2)
            {
                HttpMethod = requestLines[0];
                Url = requestLines[1];
                HttpVersion = requestLines[2];
            }
        }
        // 请求方式：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 = "404";
                context.Response.StateDescription = "Not Found";
                context.Response.ContentType = "text/html";
                string notExistHtml = Path.Combine(bastPath, @"LZZWebSite
otfound.html");
                context.Response.Body = File.ReadAllBytes(notExistHtml);
            }
            else
            {
                context.Response.StateCode = "200";
                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 = "200";
            context.Response.ContentType = "text/html";
            context.Response.StateDescription = "OK";
        }
    }

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

运行图：