专栏名称: python
隔天更新python文章，我希望用我的努力换来劳动的成果帮助更多的人掌握一门技术，因此我要更加努力。
目录
相关文章推荐
Python爱好者社区  ·  英伟达憾失DeepSeek关键人才？美国放走 ... ·  昨天  
Python爱好者社区  ·  DeepSeek创始人梁文锋个人履历 ·  3 天前  
Python爱好者社区  ·  离谱！下载DeepSeek最高判刑20年？ ·  2 天前  
Python爱好者社区  ·  1885页的Python完全版电子书 ·  3 天前  
Python开发者  ·  请立即拿下软考证书（政策风口） ·  4 天前  
51好读  ›  专栏  ›  python

Django：浏览器访问服务器的过程。

python  · 公众号  · Python  · 2019-12-29 22:32

正文


用户通过浏览器浏览网站的过程：

用户浏览器（socket客户端）

客户端往服务端发消息
客户端接收消息
关闭

网站服务器（socket服务端）

启动,监听
等待客户端连接
服务端收消息
服务端回消息
关闭（一般都不会关闭）

下面，我们先写一个服务端程序，来模拟浏览器服务器访问过程。

你会发现，运行程序之后并且用浏览器访问 127.0.0.1:8001 ，程序会报错，浏览器显示“该网页无法正常运作”，如下图

为什么呢？这时候就要引出 HTTP 协议 了。

HTTP协议

HTTP是一个客户端终端（用户）和服务器端（网站）请求和应答的标准（TCP）。

HTTP请求/响应步骤：

1. 客户端连接到Web服务器
一个HTTP客户端，通常是浏览器，与Web服务器的HTTP端口（默认为80）建立一个TCP套接字连接。

2. 发送HTTP请求
通过TCP套接字，客户端向Web服务器发送一个文本的请求报文，一个请求报文由请求行、请求头部、空行和请求数据4部分组成。

3. 服务器接受请求并返回HTTP响应
Web服务器解析请求，定位请求资源。服务器将资源复本写到TCP套接字，由客户端读取。一个响应由状态行、响应头部、空行和响应数据4部分组成。

4. 释放连接TCP连接
若connection 模式为close，则服务器主动关闭TCP连接，客户端被动关闭连接，释放TCP连接；若connection 模式为keepalive，则该连接会保持一段时间，在该时间内可以继续接收请求;

5. 客户端浏览器解析HTML内容
客户端浏览器首先解析状态行，查看表明请求是否成功的状态代码。然后解析每一个响应头，响应头告知以下为若干字节的HTML文档和文档的字符集。客户端浏览器读取响应数据HTML，根据HTML的语法对其进行格式化，并在浏览器窗口中显示。

浏览器和服务端通信都要遵循一个HTTP协议(消息的格式要求)

关于HTTP协议：

1. 浏览器往服务端发的叫 请求(request)
请求的消息格式:

请求方法 路径 HTTP/1.1\r\n
k1:v1\r\n
k2:v2\r\n
\r\n
请求数据

2. 服务端往浏览器发的叫 响应(response)
响应的消息格式:

HTTP/1.1 状态码 状态描述符\r\n
k1:v1\r\n
k2:v2\r\n
\r\n
响应正文

HTTP请求报文格式：

HTTP响应报文格式：

再回到我们刚才的程序，程序报错的原因是接收到了浏览器的访问报文请求，但是我们的服务器程序在响应的时候并没有按照HTTP响应格式（一个响应由状态行、响应头部、空行和响应数据4部分组成）进行回应，所以浏览器在处理服务器的响应的时候就会出错。

因此，我们要在发送给浏览器的响应中按照HTTP响应格式加上 状态行、响应头部、空行和响应数据 这四部分。

这时候，在浏览器上面就可以看到正确的页面了，并且可以调出Chrome的开发者工具查看到我们传过来的HTTP响应格式。

根据不同的路径返回不同的内容

细心的你可能会发现，现在无论我们输出什么样的路径，只要保持 IP 和端口号不变，浏览器页面显示的都是同样的内容，这不太符合我们日常的使用场景。

如果我想根据不同的路径返回不同的内容，应该怎么办呢？

这时候就需要我们把服务器收到的请求报文进行解析，读取到其中的访问路径。

观察收到的HTTP请求，会发现，它们的请求行、请求头部、请求数据是以 \r\n 进行分隔的，所以我们可以根据 \r\n 对收到的请求进行分隔，取出我们想要的访问路径。

  1. """

  2. 完善的web服务端示例

  3. 根据不同的路径返回不同的内容

  4. """

  6. import socket

  8. # 生成socket实例对象

  9. sk = socket . socket ()

  10. # 绑定IP和端口

  11. sk . bind (( "127.0.0.1" , 8001 ))

  12. # 监听

  13. sk . listen ()

  15. # 写一个死循环,一直等待客户端来连接

  16. while 1 :

  17. # 获取与客户端的连接

  18. conn , _ = sk . accept ()

  19. # 接收客户端发来消息

  20. data = conn . recv ( 8096 )

  21. # 把收到的数据转成字符串类型

  22. data_str = str ( data , encoding = "utf-8" ) # bytes("str", enconding="utf-8")

  23. # print(data_str)

  24. # 用\r\n去切割上面的字符串

  25. l1 = data_str . split ( "\r\n" )

  26. # l1[0]获得请求行，按照空格切割上面的字符串

  27. l2 = l1 [ 0 ]. split ()

  28. # 请求行格式为：请求方法 URL 协议版本，因此 URL 是 l2[1]

  29. url = l2 [ 1 ]

  30. # 给客户端回复消息

  31. conn . send ( b 'http/1.1 200 OK\r\ncontent-type:text/html; charset=utf-8\r\n\r\n' )

  32. # 想让浏览器在页面上显示出来的内容都是响应正文

  34. # 根据不同的url返回不同的内容

  35. if url == "/yimi/" :

  36. response = b '

    hello yimi!

    '

  37. elif url == "/xiaohei/" :

  38. response = b '

    hello xiaohei!

    '

  39. else :

  40. response = b '

    404! not found!

    '

  41. conn . send ( response )

  42. # 关闭

  43. conn . close ()

  44. sk . close ()


这时候，我们访问不同的路径，例如 http://127.0.0.1:8001/yimi/   http://127.0.0.1:8001/xiaohei/ 会在浏览器上显示不一样的内容

可以看到，我们现在的程序逻辑不是很清晰，我们可以改一下，url 用一个列表存起来，url 对应的响应分别写成一个个函数，通过函数调用进行 url 访问，你会发现，这跟某个框架的处理方式很像很像（偷笑罒ω罒~~~）

  1. """

  2. 完善的web服务端示例

  3. 函数版根据不同的路径返回不同的内容

  4. 进阶函数版 不写if判断了,用url名字去找对应的函数名

  5. """

  7. import socket

  9. # 生成socket实例对象

  10. sk = socket . socket ()

  11. # 绑定IP和端口

  12. sk . bind (( "127.0.0.1" , 8001 ))

  13. # 监听

  14. sk . listen ()

  16. # 定义一个处理/yimi/的函数

  17. def yimi ( url ):

  18. ret = '

    hello {}

    ' . format ( url )

  19. # 因为HTTP传的是字节，所以要把上面的字符串转成字节

  20. return bytes ( ret , encoding = "utf-8" )

  23. # 定义一个处理/xiaohei/的函数

  24. def xiaohei ( url ):

  25. ret = '

    hello {}

    ' . format ( url )

  26. return bytes ( ret , encoding = "utf-8" )

  29. # 定义一个专门用来处理404的函数

  30. def f404 ( url ):

  31. ret = "

    你访问的这个{} 找不到

    " . format ( url )

  32. return bytes ( ret , encoding = "utf-8" )

  35. url_func = [

  36. ( "/yimi/" , yimi ),

  37. ( "/xiaohei/" , xiaohei ),

  38. ]

  41. # 写一个死循环,一直等待客户端来连我

  42. while 1 :

  43. # 获取与客户端的连接

  44. conn , _ = sk . accept ()

  45. # 接收客户端发来消息

  46. data = conn . recv ( 8096 )

  47. # 把收到的数据转成字符串类型

  48. data_str = str ( data , encoding = "utf-8" ) # bytes("str", enconding="utf-8")

  49. # print(data_str)

  50. # 用\r\n去切割上面的字符串

  51. l1 = data_str . split ( "\r\n" )

  52. # print(l1[0])

  53. # 按照空格切割上面的字符串

  54. l2 = l1 [ 0 ]. split ()

  55. url = l2 [ 1 ]

  56. # 给客户端回复消息

  57. conn . send ( b 'http/1.1 200 OK\r\ncontent-type:text/html; charset=utf-8\r\n\r\n' )

  58. # 想让浏览器在页面上显示出来的内容都是响应正文

  60. # 根据不同的url返回不同的内容

  61. # 去url_func里面找对应关系

  62. for i in url_func :

  63. if i [ 0 ] == url :

  64. func = i [ 1 ]

  65. break

  66. # 找不到对应关系就默认执行f404函数

  67. else :

  68. func = f404

  70. # 拿到函数的执行结果

  71. response = func ( url )

  72. # 将函数返回的结果发送给浏览器

  73. conn . send ( response )

  74. # 关闭连接

  75. conn . close ()

返回具体的 HTML 页面

现在，你可能会在想，目前我们想要返回的内容是通过函数进行返回的，返回的都是一些简单地字节，如果我想要返回一个已经写好的精美的 HTML 页面应该怎么办呢？

我们可以把写好的 HTML 页面以二进制的形式读取进来，返回给浏览器，浏览器再进行解析，这就可以啦！

  1. """

  2. 完善的web服务端示例

  3. 函数版根据不同的路径返回不同的内容

  4. 进阶函数版 不写if判断了,用url名字去找对应的函数名

  5. 返回html页面

  6. """

  8. import socket

  10. # 生成socket实例对象

  11. sk = socket . socket ()

  12. # 绑定IP和端口

  13. sk . bind (( "127.0.0.1" , 8001 ))

  14. # 监听

  15. sk . listen ()

  18. # 定义一个处理/yimi/的函数

  19. def yimi ( url ):

  20. # 以二进制的形式读取

  21. with open ( "yimi.html" , "rb" ) as f :

  22. ret = f . read ()

  23. return ret

  26. # 定义一个处理/xiaohei/的函数

  27. def xiaohei ( url ):

  28. with open ( "xiaohei.html" , "rb" ) as f :

  29. ret = f . read ()

  30. return ret

  33. # 定义一个专门用来处理404的函数

  34. def f404 ( url ):

  35. ret = "

    你访问的这个{} 找不到

    " . format ( url )

  36. return bytes ( ret , encoding = "utf-8" )

  39. # 用户访问的路径和后端要执行的函数的对应关系

  40. url_func = [

  41. ( "/yimi/" , yimi ),

  42. ( "/xiaohei/" , xiaohei ),

  43. ]

  46. # 写一个死循环,一直等待客户端来连我

  47. while 1 :

  48. # 获取与客户端的连接

  49. conn , _ = sk . accept ()

  50. # 接收客户端发来消息

  51. data = conn . recv ( 8096 )

  52. # 把收到的数据转成字符串类型

  53. data_str = str ( data , encoding = "utf-8" ) # bytes("str", enconding="utf-8")

  54. # print(data_str)

  55. # 用\r\n去切割上面的字符串

  56. l1 = data_str . split ( "\r\n" )

  57. # print(l1[0])

  58. # 按照空格切割上面的字符串

  59. l2 = l1 [ 0 ]. split ()

  60. url = l2 [ 1 ]

  61. # 给客户端回复消息

  62. conn . send ( b 'http/1.1 200 OK\r\ncontent-type:text/html; charset=utf-8\r\n\r\n' )

  63. # 想让浏览器在页面上显示出来的内容都是响应正文

  65. # 根据不同的url返回不同的内容

  66. # 去url_func里面找对应关系

  67. for i in url_func :

  68. if i [ 0 ] == url :

  69. func = i [ 1 ]

  70. break

  71. # 找不到对应关系就默认执行f404函数

  72. else :

  73. func = f404

  74. # 拿到函数的执行结果

  75. response = func ( url )

  76. # 将函数返回的结果发送给浏览器

  77. conn . send ( response )

  78. # 关闭连接

  79. conn . close ()

返回动态 HTML 页面

这时候，你可能又会纳闷，现在返回的都是些静态的、固定的 HTML 页面，如果我想返回一个动态的 HTML 页面，应该怎么办？

动态的网页，本质上都是字符串的替换，字符串替换发生服务端，替换完再返回给浏览器。

这里，我们通过返回一个当前时间，来模拟动态 HTML 页面的返回过程。

  1. """

  2. 完善的web服务端示例

  3. 函数版根据不同的路径返回不同的内容

  4. 进阶函数版 不写if判断了,用url名字去找对应的函数名

  5. 返回html页面

  6. 返回动态的html页面

  7. """

  9. import socket

  10. import time

  12. # 生成socket实例对象

  13. sk = socket . socket ()

  14. # 绑定IP和端口

  15. sk . bind (( "127.0.0.1" , 8001 ))

  16. # 监听

  17. sk . listen ()

  19. # 定义一个处理/yimi/的函数

  20. def yimi ( url ):

  21. with open ( "yimi.html" , "r" , encoding = "utf-8" ) as f :

  22. ret = f . read ()

  23. # 得到替换后的字符串

  24. ret2 = ret . replace ( "@@xx@@" , str ( time . ctime ()))

  25. return bytes ( ret2 , encoding = "utf-8" )

  28. # 定义一个处理/xiaohei/的函数

  29. def xiaohei ( url ):

  30. with open ( "xiaohei.html" , "rb" ) as f :

  31. ret = f . read ()

  32. return ret

  35. # 定义一个专门用来处理404的函数

  36. def f404 ( url ):

  37. ret = "你访问的这个{} 找不到" . format ( url )

  38. return bytes ( ret , encoding = "utf-8" )

  41. url_func = [

  42. ( "/yimi/" , yimi ),

  43. ( "/xiaohei/" , xiaohei ),

  44. ]

  47. # 写一个死循环,一直等待客户端来连我

  48. while 1 :

  49. # 获取与客户端的连接

  50. conn , _ = sk . accept ()

  51. # 接收客户端发来消息

  52. data = conn . recv ( 8096 )

  53. # 把收到的数据转成字符串类型

  54. data_str = str ( data , encoding = "utf-8" ) # bytes("str", enconding="utf-8")

  55. # print(data_str)

  56. # 用\r\n去切割上面的字符串

  57. l1 = data_str . split ( "\r\n" )

  58. # print(l1[0])

  59. # 按照空格切割上面的字符串

  60. l2 = l1 [ 0 ]. split ()

  61. url = l2 [ 1 ]

  62. # 给客户端回复消息

  63. conn . send ( b 'http/1.1 200 OK\r\ncontent-type:text/html; charset=utf-8\r\n\r\n' )

  64. # 想让浏览器在页面上显示出来的内容都是响应正文

  66. # 根据不同的url返回不同的内容

  67. # 去url_func里面找对应关系







请到「今天看啥」查看全文


推荐文章
Python爱好者社区  ·  英伟达憾失DeepSeek关键人才？美国放走AI「钱学森」，哈佛教授痛心疾首
昨天
Python爱好者社区  ·  DeepSeek创始人梁文锋个人履历
3 天前
Python爱好者社区  ·  离谱！下载DeepSeek最高判刑20年？
2 天前
Python爱好者社区  ·  1885页的Python完全版电子书
3 天前
Python开发者  ·  请立即拿下软考证书（政策风口）
4 天前
历史震惊你  ·  解密丨中国抗战时期的三个最艰危时刻，老蒋决定了最后的存亡
8 年前
东方时代环球时事解读  ·  马英九的面具，总归会有人去揭的！
7 年前
马后炮化工  ·  安全标志多知道，安全生产很管用！
7 年前
极客基地  ·  等等！别射脸上，老司机来教你正确“打手枪”!
7 年前
健康界  ·  人民日报“三问”住培制度：标准化医生怎么炼成
7 年前
Sov5搜索   ·   小百科   ·   今天看啥   ·   移动版
51好读 - 好文章就要读起来!