zoukankan      html  css  js  c++  java

  • python-web服务器

    一、HTTP协议

    1、HTTP协议简介

    在Web应用中，服务器把网页传给浏览器，实际上就是把网页的HTML代码发送给浏览器，让浏览器显示出来。而浏览器和服务器之间的传输协议是HTTP，所以：

    • HTML是一种用来定义网页的文本，会HTML，就可以编写网页；

    • HTTP是在网络上传输HTML的协议，用于浏览器和服务器的通信。

    Chrome浏览器提供了一套完整地调试工具，非常适合Web开发。

    2. http协议的分析

    当我们在地址栏输入www.baidu.com时，浏览器将显示新浪的首页。在这个过程中，浏览器都干了哪些事情呢？通过Network的记录，我们就可以知道。在Network中，找到www.baidu.com那条记录，点击，右侧将显示Request Headers，点击右侧的view source，我们就可以看到浏览器发给新浪服务器的请求：

    2.1 浏览器请求

    说明

    最主要的头两行分析如下，第一行：

     GET / HTTP/1.1

    GET表示一个读取请求，将从服务器获得网页数据，/表示URL的路径，URL总是以/开头，/就表示首页，最后的HTTP/1.1指示采用的HTTP协议版本是1.1。目前HTTP协议的版本就是1.1，但是大部分服务器也支持1.0版本，主要区别在于1.1版本允许多个HTTP请求复用一个TCP连接，以加快传输速度。

    从第二行开始，每一行都类似于Xxx: abcdefg：

     Host: www.baidu.com

    表示请求的域名是www.baidu.com。如果一台服务器有多个网站，服务器就需要通过Host来区分浏览器请求的是哪个网站。

    2.2 服务器响应

    HTTP响应分为Header和Body两部分（Body是可选项），我们在Network中看到的Header最重要的几行如下：

    HTTP/1.1 200 OK

    200表示一个成功的响应，后面的OK是说明。

    如果返回的不是200，那么往往有其他的功能，例如

    • 失败的响应有404 Not Found：网页不存在
    • 500 Internal Server Error：服务器内部出错
    • 302，重定向
        Content-Type: text/html

     

    Content-Type指示响应的内容，这里是text/html表示HTML网页。

    请注意，浏览器就是依靠Content-Type来判断响应的内容是网页还是图片，是视频还是音乐。浏览器并不靠URL来判断响应的内容，所以，即使URL是http://www.baidu.com/meitu.jpg，它也不一定就是图片。

    HTTP响应的Body就是HTML源码，我们在菜单栏选择“视图”，“开发者”，“查看网页源码”就可以在浏览器中直接查看HTML源码：

    浏览器解析过程

    当浏览器读取到新浪首页的HTML源码后，它会解析HTML，显示页面，然后，根据HTML里面的各种链接，再发送HTTP请求给新浪服务器，拿到相应的图片、视频、Flash、JavaScript脚本、CSS等各种资源，最终显示出一个完整的页面。所以我们在Network下面能看到很多额外的HTTP请求

    3. 总结

    3.1 HTTP请求

    跟踪了百度的首页，我们来总结一下HTTP请求的流程：

    3.1.1 步骤1：浏览器首先向服务器发送HTTP请求，请求包括：

    方法：GET还是POST，GET仅请求资源，POST会附带用户数据；

    路径：/full/url/path；

    域名：由Host头指定：Host: www.baidu.com

    以及其他相关的Header；

    如果是POST，那么请求还包括一个Body，包含用户数据

    3.1.1 步骤2：服务器向浏览器返回HTTP响应，响应包括：

    响应代码：200表示成功，3xx表示重定向，4xx表示客户端发送的请求有错误，5xx表示服务器端处理时发生了错误；

    响应类型：由Content-Type指定；

    以及其他相关的Header；

    通常服务器的HTTP响应会携带内容，也就是有一个Body，包含响应的内容，网页的HTML源码就在Body中。

    3.1.1 步骤3：如果浏览器还需要继续向服务器请求其他资源，比如图片，就再次发出HTTP请求，重复步骤1、2。

    Web采用的HTTP协议采用了非常简单的请求-响应模式，从而大大简化了开发。当我们编写一个页面时，我们只需要在HTTP请求中把HTML发送出去，不需要考虑如何附带图片、视频等，浏览器如果需要请求图片和视频，它会发送另一个HTTP请求，因此，一个HTTP请求只处理一个资源(此时就可以理解为TCP协议中的短连接，每个链接只获取一个资源，如需要多个就需要建立多个链接)

    HTTP协议同时具备极强的扩展性，虽然浏览器请求的是http://www.baidu.com的首页，但是新浪在HTML中可以链入其他服务器的资源，比如<img src="http://i1.baiduimg.cn/home/2013/1008/U84123.png">，从而将请求压力分散到各个服务器上，并且，一个站点可以链接到其他站点，无数个站点互相链接起来，就形成了World Wide Web，简称WWW。

    3.2 HTTP格式

    每个HTTP请求和响应都遵循相同的格式，一个HTTP包含Header和Body两部分，其中Body是可选的。

    HTTP协议是一种文本协议，所以，它的格式也非常简单。

    3.2.1 HTTP GET请求的格式：

        GET /path HTTP/1.1
    Header1: Value1
    Header2: Value2
    Header3: Value3
    ......

    每个Header一行一个，换行符是 。

    3.2.2 HTTP POST请求的格式：

        POST /path HTTP/1.1
    Header1: Value1
    Header2: Value2
    Header3: Value3

    body data goes here...

    当遇到连续两个 时，Header部分结束，后面的数据全部是Body。

    3.2.3 HTTP响应的格式：

        200 OK
    Header1: Value1
    Header2: Value2
    Header3: Value3

    body data goes here...

    HTTP响应如果包含body，也是通过 来分隔的。

    请再次注意，Body的数据类型由Content-Type头来确定，如果是网页，Body就是文本，如果是图片，Body就是图片的二进制数据。

    当存在Content-Encoding时，Body数据是被压缩的，最常见的压缩方式是gzip，所以，看到Content-Encoding: gzip时，需要将Body数据先解压缩，才能得到真正的数据。压缩的目的在于减少Body的大小，加快网络传输。

    二 、案列

    Web静态服务器-1

     1 #coding-=utf-8
 2 '''
 3 Created on 2019年8月9日
 4 
 5 @author: Administrator
 6 
 7 #Web静态服务器-1-显示固定的页面
 8 '''
 9 import socket
10 from multiprocessing import Process
11 
12 def handleClient(clientSocket):
13     '用一个新进程为一个客户端进行服务'
14     recvData = clientSocket.recv(2014)
15     requestHeaderLines = recvData.splitlines()
16     for line in requestHeaderLines:
17         print(line)
18         
19     'response header '
20     responseHeaderLines = 'HTTP/1.1 200 OK
'
21     responseHeaderLines += '
'
22     
23     responseBody = 'hello world'
24     
25     response = responseHeaderLines + responseBody
26     clientSocket.send(response.encode())
27     clientSocket.close()
28     
29     
30 def main():
31     '作为程序入口'  
32     serverSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
33     #serverSocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
34     serverSocket.bind(('',9999))
35     serverSocket.listen()
36     
37     while True:
38         clientSocket,clientAddr = serverSocket.accept()
39         p = Process(target=handleClient, args=(clientSocket,))
40         p.start()
41 
42 if __name__ == '__main__':
43     main()
    webStaticServer01

    Web静态服务器-2

     1 #coding-=utf-8
 2 '''
 3 Created on 2019年8月9日
 4 
 5 @author: Administrator
 6 
 7 #Web静态服务器-2-显示需要的页面
 8 '''
 9 import socket
10 from multiprocessing import Process
11 import re
12 
13 
14 def handleClient(clientSocket):
15     '用一个新进程为一个客户端进行服务'
16     recvData = clientSocket.recv(2014)
17     requestHeaderLines = recvData.splitlines()
18     for line in requestHeaderLines:
19         print(line)
20         
21     #httpRequestMethodLine = requestHeaderLines[0].decode('utf-8')
22     #getFileName = re.match("[^/]+(/[^ ]*)", httpRequestMethodLine).group(1)
23     #print('getFileName:%s'%getFileName)
24     filename = requestHeaderLines[0].decode('utf-8').split(' ')[1]
25     print('filename:%s'%filename)
26         
27     if filename == '/':
28         filename = documentRoot + "/index.html"#默认返回的页面
29     else:
30         filename = documentRoot + filename#请求的页面
31         
32     print('request-filename:%s'%filename)
33     
34     try:
35         f = open(filename,'r',encoding='UTF-8')
36         responseHeaderLines = 'HTTP/1.1 200 OK
'
37         responseHeaderLines += '
'
38         responseBody = f.read()
39         f.close()#close file
40     except Exception as e:
41         print('[error]Exception:%s'%e)
42         responseHeaderLines = 'HTTP/1.1 404 NOT FOUND
'
43         responseHeaderLines += '
'
44         responseBody = '=====sorry, page not found====='
45     finally:
46         response = responseHeaderLines + responseBody
47         clientSocket.send(response.encode())
48         clientSocket.close()
49         
50 def main():
51     '作为程序入口'  
52     serverSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
53     #serverSocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
54     serverSocket.bind(('',9999))
55     serverSocket.listen()
56     
57     while True:
58         clientSocket,clientAddr = serverSocket.accept()
59         p = Process(target=handleClient, args=(clientSocket,))
60         p.start()
61 
62 #配置
63 documentRoot = './html'
64 
65 if __name__ == '__main__':
66     main()
    webStaticServer02

    三、服务器动态资源请求

    1. 浏览器请求动态页面过程

    1.1 WSGI介绍

    PythonWeb服务器网关接口（Python Web Server Gateway Interface，缩写为WSGI)是Python应用程序或框架和Web服务器之间的一种接口，

    WSGI接口定义非常简单，它只要求Web开发者实现一个函数，就可以响应HTTP请求。

    # WSGI 规范的函数
def application(environ, start_response):
    start_response('200 OK', [('Content-Type', 'text/html')])
    return '<h1>Hello, Se7eN_HOU!</h1>'

    上面的application()函数就是符合WSGI标准的一个HTTP处理函数，它接收两个参数：

      • environ：一个包含所有HTTP请求信息的dict对象；
      • start_response：一个发送HTTP响应的函数。

    在application()函数中，调用：

    start_response('200 OK', [('Content-Type', 'text/html')])

    1.2  运行WSGI服务

    1、 Python内置了一个WSGI服务器，这个模块叫wsgiref，首先我们先实现一个hello.py文件，实现Web应用程序的WSGI处理函数

    def application(environ, start_response):
    start_response("200 OK",[("Content-Type","text/html")])
    return "<h1>Hello,Se7eN_HOU!</h1>"

    2、然后，再编写一个server.py，负责启动WSGI服务器，加载application()函数：

    #coding:utf-8

# 导入wsgiref模块
from wsgiref.simple_server import make_server
from hello import application


# 创建一个服务器，IP地址为空，端口号为7788，处理的函数是application
httpServer = make_server("", 7788, application)
# 开始监听HTTP请求
httpServer.serve_forever()

    3、  确保以上两个文件在同一个目录下，然后使用命令行输入python server.py来启动WSGI服务器：

    houleideMacPro:WSGI Se7eN_HOU$ python server.py
127.0.0.1 - - [19/Jun/2019 15:52:37] "GET / HTTP/1.1" 200 24
127.0.0.1 - - [19/Jun/2019 15:52:37] "GET /favicon.ico HTTP/1.1" 200 24

    4、 按Ctrl+C终止服务器。如果你觉得这个Web应用太简单了，可以稍微改造一下，从environ里读取PATH_INFO，这样可以显示更加动态的内容：
    def application(environ, start_response):
    start_response("200 OK",[("Content-Type","text/html")])
    return "<h1>Hello,%s</h1>"%(environ["PATH_INFO"][1:] or "Se7eN_HOU")

    　5、 你可以在地址栏输入用户名作为URL的一部分，

     四、案列

    1、web动态服务器-1

      1 #coding=utf-8
  2 '''
  3 Created on 2019年8月9日
  4 
  5 @author: Administrator
  6 '''
  7 import socket
  8 from multiprocessing import Process
  9 import re
 10 import sys
 11 
 12 class WSGIServer(object):
 13     
 14     addressFamily = socket.AF_INET
 15     socketType = socket.SOCK_STREAM
 16     requestQueuesize = 5
 17     
 18     def __init__(self, serverAddress):
 19         #创建tcp套接字
 20         #self.listenSocket = socket(self.addressFamily, self.socketType)
 21         self.listenSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 22         #允许重复使用上次的套接字绑定的port
 23         self.listenSocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 24         #绑定
 25         self.listenSocket.bind(serverAddress)
 26         #被动监听，并制定队列长度
 27         self.listenSocket.listen(self.requestQueuesize)
 28         
 29         #self.serverName = 'localhost'
 30         #self.serverPort = serverAddress[1]
 31     
 32     def serverForever(self):
 33         #'循环运行web服务器，等待客户端的连接并为客户端服务'
 34         while True:
 35             #等待新客户端
 36             self.clientSocket, client_address = self.listenSocket.accept()
 37             
 38             #为每一个客户端创建新进程，
 39             newClientProcess = Process(target=self.handleClient)
 40             newClientProcess.start()
 41             #处理完之后，关闭
 42             self.clientSocket.close()
 43             
 44     def setApp(self, application):
 45         '设置此WSGI服务器调用的应用程序入口函数'
 46         self.application = application       
 47             
 48     def handleClient(self):       
 49         self.recvData = self.clientSocket.recv(2048)
 50         print('self.recvData:%s'%self.recvData)
 51         if self.recvData:#过滤空
 52             requestHeaderLines = self.recvData.splitlines()
 53             
 54             for line in requestHeaderLines:
 55                 print(line)
 56             
 57             print('requestHeaderLines[0]:%s'%requestHeaderLines[0])
 58             filename = requestHeaderLines[0].decode('utf-8').split(' ')[1]
 59             print('filename:%s'%filename)
 60             
 61             if filename[-3:] != '.py':
 62                 if filename == '/':
 63                     filename = documentRoot + "/index.html"#默认返回的页面
 64                 else:
 65                     filename = documentRoot + filename#请求的页面
 66                     
 67                 print('request-filename:%s'%filename)
 68                 
 69                 try:
 70                     f = open(filename,'r',encoding='UTF-8')
 71                     responseHeaderLines = 'HTTP/1.1 200 OK
'
 72                     responseHeaderLines += '
'
 73                     responseBody = f.read()
 74                     f.close()#close file
 75                 except Exception as e:
 76                     print('[error]Exception:%s'%e)
 77                     responseHeaderLines = 'HTTP/1.1 404 NOT FOUND
'
 78                     responseHeaderLines += '
'
 79                     responseBody = '=====sorry, page not found====='
 80                 finally:
 81                     response = responseHeaderLines + responseBody
 82                     self.clientSocket.send(response.encode())
 83                     self.clientSocket.close()
 84             else:
 85                 #处理接收到的请求头
 86                 self.parseRequest()
 87                 #根据接收到的请求头构造环境变量字典
 88                 env = self.getEnviron() 
 89                 #调用应用的相应方法，完成动态数据的获取      
 90                 bodyContent = self.application(env, self.startResponse)
 91                 #组织数据发送给客户端
 92                 self.finishResponse(bodyContent)
 93             
 94     def parseRequest(self):
 95         '提取出客户端发送的request'
 96         requestLine = self.recvData.splitlines()[0]
 97         requestLine = requestLine.rstrip(b'
')   
 98         print('requestLine:%s'%requestLine)
 99         self.requestMethod, self.path, self.requestVersion = requestLine.split(b" ")
100       
101     def getEnviron(self): 
102         env = {}
103         env['wsgi.version']      = (1, 0)
104         env['wsgi.input']        = self.recvData
105         env['REQUEST_METHOD']    = self.requestMethod    # GET
106         env['PATH_INFO']         = self.path             # /index.html
107         return env
108          
109     #def startResponse(self, status, response_headers, exc_info=None)     
110     def startResponse(self, status, response_headers, exc_info=None):
111         serverHeaders = [
112             ('Date', 'Fri, 9 Augs 2019 14:00:00 GMT'),
113             ('Server', 'WSGIServer 0.2'),
114             ]
115         self.headers_set = [status, response_headers+serverHeaders]
116             
117     def finishResponse(self,bodyContent):    
118         try:
119             status, response_headers = self.headers_set
120             #response第一行
121             response = 'HTTP/1.1 {status}
'.format(status=status)
122             #其他头信息
123             for header in response_headers:
124                 response += '{0}: {1}
'.format(*header)
125             #添加一个换行，与body进行分开来
126             response += '
'
127             #添加发送的数据
128             for data in bodyContent:
129                 response += data
130             
131             self.clientSocket.send(response.encode())
132             
133         finally:
134             self.clientSocket.close()   
135              
136                 
137       
138 #设定服务器的端口
139 serverAddr = (HOST, PORT) = '',9999 
140 #设置服务器静态资源的路径
141 documentRoot = './html'
142 #设置服务器胴体资源路径      
143 pythonRoot = './wsgiPy'        
144 
145 def makeServer(serverAddr, application):
146     server = WSGIServer(serverAddr)
147     server.setApp(application)
148     return server
149 
150 def main():
151     if len(sys.argv) < 2:
152         sys.exit('请按照要求，制定模块名称：应用名称，例如：module:callable')
153     #获取module:callable
154     appPath = sys.argv[1]
155     print('appPath:%s'%appPath)
156     #根据冒号切割为module和callable
157     module,application = appPath.split(':')
158     #添加路径到 sys.path
159     sys.path.insert(0,pythonRoot)
160     #动态导入module变量中的指定模块
161     module = __import__(module)
162     #获取module变量中指定的模块，application变量指定的属性
163     application = getattr(module, application)
164     httpd = makeServer(serverAddr, application)
165     print('WSGIServer: Serving HTTP on port %d ...
'%PORT)
166     httpd.serverForever()
167     
168 if __name__ == '__main__':
169     main()
170     
171
    webDynamicServer01

    2、应用程序代码ctime.py

     1 #coding=utf-8
 2 '''
 3 Created on 2019年8月12日
 4 
 5 @author: Administrator
 6 '''
 7 import time
 8 
 9 def app(environ, start_response):
10     status = '200 OK'
11     
12     response_headers = [
13         ("Content-Type", "text/plain")
14     ]
15     
16     start_response(status, response_headers)
17     
18     return [str(environ)+'--->%s
'%time.ctime()]
19
    ctime

    3、运行

    3.1  在脚本所在的目录 按住shift +鼠标右键，右键菜单选择在此处打开命令窗口

    3.2  在命令窗口运行脚本（python3 webDynamicServer01.py ctime:app）

    看到如下页面即服务启动成功

    3.3  在浏览器中输入http://127.0.0.1:9999/，可返回index.html：

     

     
  • 相关阅读:
    命名对象继承2-验证Open*命名对象安全属性的传递
    命名对象继承1-验证Create*命名对象安全属性的传递
    讨论c/c++计算小数的精度问题
    隐藏进程名
    一个函数重载问题
    02-Python基础之列表
    01-Python基础之字符串
    django 实用工具dj-database-url 快速配置数据库
    Gerrit安装配置
    关于数学的摘抄
  • 原文地址：https://www.cnblogs.com/yaner2018/p/11342132.html
Copyright © 2011-2022 走看看