[传智播客学习日记]手写Web服务器

花了两天的时间搞的这个，写这个东西目的就是要搞清楚ASP.Net的运作原理。

这个山寨服务器的界面很简单，三个文本框，写IP、端口，还有一个显示报文。一个连接按钮。窗体嘛...就叫Form1吧。代码比较冗长...

第一步：

 1 //搭建好窗口，为了防止意外，先：
 2 public Form1()
 3 {
 4     Control.CheckForIllegalCrossThreadCalls = false;
 5     InitializeComponent();
 6 }
 7 //全局线程th用于监听，当窗口关闭时，
 8 private void Form1_FormClosing(object sender, FormClosingEventArgs e)
 9 {
10     if (th != null)
11     {
12         th.Abort();
13     }
14 }
15 //另外定义ShowMsg方法：
16 void ShowMsg(string msg)
17 {
18     txtLog.Text += msg + "\r\n";
19 }

第二步：
在线程中进行循环监听，不多解释了，还是Socket那一套（可以看我上一篇博文）：

 1 Thread th;
 2 private void btnStart_Click(object sender, EventArgs e)
 3 {
 4     IPAddress ip = IPAddress.Parse(txtIp.Text);
 5     IPEndPoint endpoint = new IPEndPoint(ip, int.Parse(txtPort.Text));
 6     Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
 7 
 8     try
 9     {
10         socket.Bind(endpoint);
11     }
12     catch (Exception ex)
13     {
14         ShowMsg(ex.Message);
15         return;
16     }
17     socket.Listen(10);
18     ShowMsg("开始运行.....");
19 
20     btnStart.Enabled = false;
21 
22     th = new Thread(Listen);
23     th.IsBackground = true;
24     th.Start(socket);
25 }
26 //监听用的方法
27 void Listen(object o)
28 {
29     Socket socket = o as Socket;
30     while (true)
31     {
32         Socket connect = socket.Accept();
33     DataConnection conn = new DataConnection(connect, ShowMsg);
34     }
35 }

第三步：
由于每次传输完信息连接就可以断开了，所以没必要用循环来接受客户端请求。注意到上面有个叫DataConnection的类，这个类是我们自定义的，为了不让代码显得臃肿。它的构造函数是DataConnection(Socket conn,DelShowMsg del)，第一个参数是我们通过监听用的Socket生成的负责传输的Socket，第二个参数是委托，进行报文显示。

 1 //首先我们在类外定义回显用的委托：
 2 public delegate void DelShowMsg(string msg);
 3 //下面是这个类的定义：
 4 class DataConnection
 5 {
 6     //定义委托类的对象
 7     private DelShowMsg del;
 8     //以及负责通信的socket
 9     private Socket connection;
10         
11     //之后在构造函数里初始化传进来的Socket和委托
12     public DataConnection(Socket conn,DelShowMsg del)
13     {
14         this.connection = conn;
15         this.del = del;
16 
17         //用一个字符串接收浏览器发来的请求报文
18 //这个方法也是自己写的，解释在后面
19         string msg = RecMsg();
20 
21         //然后解析请求头，这个类还是我们自己写的
22         Request req = new Request(msg);
23 
24         //根据解析后的请求头中的地址，判断请求文件的类型，并向浏览器做出响应
25 //这个方法也是自己写的，为了防止代码臃肿
26         Judge(req.Path);
27     }

（类中的方法还没写完）

第四步：
第三步中我们留下了RecMsg方法、Judge方法和Request类没有写。先来写RecMsg方法。

 1 //RecMsg方法很简单，用来接收消息
 2 string RecMsg()
 3 {
 4     //定义缓冲区
 5     byte[] buffer = new byte[1024 * 1024 * 5];
 6     //服务器获取请求报文，并返回长度
 7     int length = connection.Receive(buffer);
 8 
 9     //得到请求报文字符串
10     string msg = System.Text.Encoding.UTF8.GetString(buffer, 0, length);
11     //显示报文
12     del(msg);
13 
14     del("连接关闭");
15     return msg;
16 }

第五步：
第三步中的Request类用来解析请求报文获得请求的路径，原理就是切割字符串。

 1 class Request
 2 {
 3     public Request(string msg)
 4     {
 5         //这里根据换换行符切割报文获取每一行
 6         string[] arrLines = msg.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
 7         //然后获取请求行
 8         string[] firstLine = arrLines[0].Split(' ');
 9     //以及各个属性
10         method = firstLine[0];
11         path = firstLine[1];
12         protocol = firstLine[2];
13     }
14 
15     //山寨版服务器很简陋，这里只封装三个属性
16     private string method;
17     public string Method
18     {
19         get { return method; }
20         set { method = value; }
21     }
22 
23     private string path;
24     public string Path
25     {
26         get { return path; }
27         set { path = value; }
28     }
29 
30     private string protocol;
31     public string Protocol
32     {
33         get { return protocol; }
34         set { protocol = value; }
35     }
36 }

第六步：
接下来是第三步在DataConnection类中遗留的Judge方法，它接受上一步Request req = new Request(msg);之后得到的对象中的path属性，也就是地址，进行文件类型的判断。即Judge(req.Path);。

 1 void Judge(string path)
 2 {
 3     //首先拿到地址的扩展名，
 4     string ext = Path.GetExtension(path);
 5     //根据扩展名判断到底是静态页面还是动态页面
 6 //并分别处理
 7     switch (ext)
 8     {
 9         case ".gif":
10         case ".jpg":
11         case ".png":
12         case ".html":
13         case ".htm":
14         case ".css":
15         case ".js":
16             ProcessStaticPage(path);
17             break;
18         case ".aspx":
19         case ".jsp":
20             ProcessDyPage(path);
21             break;
22         default:
23             break;
24     }
25 }

第七步：
ProcessStaticPage和ProcessDyPage是处理静态和动态页面的两个方法，我们要通过服务器返回响应头和响应体。响应体好说，定义一个buffer就行了，问题是响应头很复杂，我们需要定义一个Response类来生成和拿到它，然后再处理ProcessStaticPage和ProcessDyPage这两个函数。这一步就是写Response类。

 1 class Response
 2 {
 3     //200是连接成功的状态字，由于大部分连接都是成功的，所以设置成默认
 4     private int status = 200;
 5     private string contentType;
 6     private int contentLength;
 7 
 8     //把状态字对应的消息放到字典里
 9     private Dictionary<int, string> dic;
10 
11     //写字典
12     void FillDic()
13     {
14         dic = new Dictionary<int, string>();
15         dic.Add(200,"OK");
16         dic.Add(404, "Object Not Found");
17         dic.Add(302, "Found");
18     }
19 
20     //默认构造函数（200的情况）
21     public Response(string ext, int contentLength)
22     {
23         this.contentLength = contentLength;
24         this.contentType = GetContentType(ext);
25         FillDic();
26     }
27 
28     //不是200的情况的构造函数，比如404了
29     public Response(int status,string ext,int contentLength)
30         :this(ext,contentLength)
31     {
32         this.status = status;
33     }
34 
35     //由于不同的后缀名对应不同的contentType
36 //就要根据后缀名生成contenttype
37     private string GetContentType(string ext)
38     {
39         string contentType = "";
40         switch (ext)
41         {
42             case ".htm":
43             case ".html":
44                 contentType = "text/html";
45                 break;
46             case ".css":
47                 contentType = "text/css";
48                 break;
49             case ".js":
50                 contentType = "text/javascript";
51                 break;
52             case ".jpg":
53                 contentType = "image/jpeg";
54                 break;
55             case ".gif":
56                 contentType = "image/gif";
57                 break;  
58             default:
59                 contentType = "text/html";
60                 break;
61         }
62         return contentType;
63     }
64 
65     //上面折腾半天就是拼接字符串呢
66 //接下来获得响应头并返回
67     public byte[] GetHeaders()
68     {
69         StringBuilder sb = new StringBuilder();
70         sb.Append("HTTP/1.1 "+status+" " + dic[status] + "\r\n");
71         sb.Append("Content-Length: " + contentLength+"\r\n");
72     //这里一定要换行，因为响应头和响应体之间有空行，否则无法解析
73         sb.Append("Content-Type: " + contentType + ";charset=utf-8\r\n\r\n");
74 
75         byte[] buffer = System.Text.Encoding.UTF8.GetBytes(sb.ToString());
76         return buffer;
77     }
78 }

第八步：
现在该写ProcessStaticPage和ProcessDyPage这两个方法来处理静态和动态页面了。先弄静态的。

 1 void ProcessStaticPage(string path)
 2 {
 3     //首先找到静态文件的绝对路径，擦掉多出来的斜杠
 4     path =AppDomain.CurrentDomain.BaseDirectory + path.Remove(0,1);
 5     //先生成获取响应头的类
 6     Response res = null;
 7     //定义好响应体
 8     byte[] buffer;
 9 
10     //然后判断请求的文件是否存在
11     if (!File.Exists(path))
12     {
13         //如果文件不存在，读取404.html
14         path = AppDomain.CurrentDomain.BaseDirectory + "404.html";
15     //然后把404页面写进响应体
16         using(FileStream fs = new FileStream(path,FileMode.Open))
17         {
18             buffer = new byte[fs.Length];
19             fs.Read(buffer, 0, buffer.Length);
20             res = new Response(404,Path.GetExtension(path), buffer.Length);
21         }
22     }
23     else
24     {
25         //如果文件存在
26         using (FileStream fs = new FileStream(path, FileMode.Open))
27         {
28             buffer = new byte[fs.Length];
29             fs.Read(buffer, 0, buffer.Length);
30             res = new Response(Path.GetExtension(path), buffer.Length);
31         }
32     }
33     //发送响应头
34     connection.Send(res.GetHeaders());
35     //发送响应体
36     connection.Send(buffer);
37     //关闭连接
38     connection.Close();
39 }

第九步：
处理动态页面麻烦一些，因为我们要根据请求的文件名来找对应同名的类，所以要用到反射技术。

 1 void ProcessDyPage(string path)
 2 {
 3     //根据请求的文件名，创建对应的类的对象
 4 //获得文件名
 5     string fileName = Path.GetFileNameWithoutExtension(path);
 6     //获得类所在的命名空间
 7     string nameSpace = System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Namespace;
 8     //获得类的全名称
 9     string fullName = nameSpace + "." + fileName;
10 
11     //注意这里，IHttpHandler是个接口，这里用了李氏替换原则
12 //保证实现了这个接口的类都能处理http请求
13     IHttpHandler hander = Assembly.GetExecutingAssembly().CreateInstance(fullName,true) as IHttpHandler;
14 
15     if (hander != null)
16     {
17       //用ProcessRequest方法处理请求
18         byte[] buffer = hander.ProcessRequest();
19         Response response = new Response(Path.GetExtension(path), buffer.Length);
20 
21         connection.Send(response.GetHeaders());
22         connection.Send(buffer);
23 
24         connection.Close();
25     }
26     else
27     {
28         //处理404，不写了
29     }
30 }

第十步：
上面有一个IHttpHandler接口，接口里面有一个byte[] ProcessRequest();方法，因为这里是用反射去找字符串对应的同名类名的，这里之所以不写判断逻辑或者简单工厂，是因为一旦判断，我每增加一个页面都要改一次代码，所以采用反射机制。接口是在动态页面对应的类中实现的，里面就是在拼html代码。比如：

 1 class MyPage : IHttpHandler
 2 {
 3     public byte[] ProcessRequest()
 4     {
 5         StringBuilder sb = "<html><body>";
 6         sb.Append("当前时间：" + DateTime.Now.ToString());
 7         sb.Append("</body></html>");
 8         string html = sb.ToString();
 9         return Encoding.UTF8.GetBytes(html);
10     }
11 }