Webserver-HTTP项目(深入理解HTTP协议)

# HTTP项目实战
- 深入理解HTTP协议
- 模拟后台服务程序基本流程和大致框架
- 每一个步骤一个文件夹
- 图解http协议， 图解tcp/ip协议

# v01-验证技术
- 验证socket-tcp技术，看能否走通流程
- 使用浏览器发送消息，访问地址

# V02-解析传入http协议
- 根据http协议格式，逐行读取信息
- 按行读取后的信息，需要进行拆解，

# 推荐书籍
- 日本人写的 “图解Http" 
- 图解系列严重推荐

# v03-http协议封装返回内容
- 返回头： "HTTP/1.1 200 OK
"
- 首部行：
  - "Content-Length: xxx
"
    - "Date: 20180616
"
- 空行：
  - "
"
- 返回内容：
  - "I love beijign tulingxueyuan"
- 例子v03

# v04-面向对象重构
- 两个对象:
    - 一个负责监听接受传入socket， WebServer
    - 一个负责通讯, SocketHandler
- 参看例子v04

# v05-使用配置文件

# v06-返回静态页面
- 静态文件：不常编辑的文件内容
- 静态文件的存储： 一般单独放入一共文件夹，或者静态文件服务器
- 需要有一共html类型的页面
- 把html文件作为文件读入内容
- 作为结果反馈回去
- 静态文件存放再： webapp文件夹下

# v07-添加路由功能和404
- 路由： 能够理解请求并按照请求调用相应处理函数的模块
  - 理解请求内容
  - 能够调用或者指定相应业务处理模块
- 算法：
  - 按行读取传入报文
  - 假如报文能用空格分割成三段，则是请求行
  - 否则，是首部行，首部行必须要能够用冒号空格分割成两段
  - 首部行是天然的键值对
  - 请求行需要自行增加键
- 404代表访问的资源不存在

# v08-添加静态文件
- 静态文件: 在web后台，一般把图片，音频，视频，附件等很少需要更改内容的文件成为静态文件
- 新建文件夹static用来存放静态文件

---

========================================

TCP传输+HTTP协议

 

HTTP协议请求头部：

 

HTTP头部解析算法：

 

添加路由：

一个socket负责通道传输，一个socket负责监听，其他的socket负责处理；

socker并发执行。

---

v01-验证技术：

import socket

# 理解两个参数的含义
# 理解创建一个socket的过程
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 注意addr的格式是tuple
# 以及tuple两个元素的含义
sock.bind(("127.0.0.1", 7852))
print("已经绑定端口........")
# 监听
sock.listen()
print("正在监听......")

# 接受一个传进来的socket
print("准备接受socket传入....")
skt, addr = sock.accept()
print("已经接收到传入socket： {0}".format(skt))

# 读取传入消息，实际上是信息
# 需要注意读取的信息的长度一定要小于等于实际消息的长度，否则会假死
msg = skt.recv(100)
print(type(msg))

# decode默认utf-8
print(msg.decode())


# 给对方一个反馈
msg = "I love only wangxiaojing"
skt.send(msg.encode())

skt.close()
sock.close()

---

解析传入HTTP：

import socket



def getHttpHeader(skt):
'''
得到传入socket的http请求头
:param skt: 通信的socket
    :return: 解析后的请求头内容，字典形式
    '''

# 读取某一行
# 直到读取的行返回空行为止

# 用来存放结果，dict类型
rst = {}

line = getLine(skt)
while line:
'''
判断得到的行是报头还是首部行，两个操作方法不一样
        算法是：
        1. 利用‘： ’作为分隔符，分割字符串
        2. 如果是首部行，则一定会把字符串分成两个子串
        3. 否则就是一个字符串
        '''
r = line.split(r': ')

if len(r) == 2:
rst[r[0]] = r[1]
else:
r = line.split(r' ')
rst['method'] = r[0]
rst['uri'] = r[1]
rst['version'] = r[2]

line = getLine(skt)

return rst




def getLine(skt):
'''
从socket中读取某一行
:param skt: ocket
    :return:  返回读取到的一行str格式内容
    '''
'''
前提:
    1. http协议传输内容是ascii编码
    2. 真正传输的内容是通过网络流传输
    3. 回车换行： b'
', b'
', b表示是一个bytes格式
    '''
# 每次从socket读取一个byte内容
b1 = skt.recv(1)
b2 = 0
#data用来存放读取的行的内容
data = b''

#当确定还没有读到一行最后，也就是回车换行符号的时候，需要循环
while b2 != b'
' and b1 != b'
':
b2 = b1
        b1 = skt.recv(1)

data += bytes(b2)

# decode 需要一个参数，即编码，但是不给的话就采用默认utf-8解码
return data.strip(b'
').decode()


# 理解两个参数的含义
# 理解创建一个socket的过程
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 注意addr的格式是tuple
# 以及tuple两个元素的含义
sock.bind(("127.0.0.1", 7852))
print("已经绑定端口........")
# 监听
sock.listen()
print("正在监听......")

# 接受一个传进来的socket
print("准备接受socket传入....")
skt, addr = sock.accept()
print("已经接收到传入socket： {0}".format(skt))

# 实际处理请求内容
http_info = getHttpHeader(skt)
print(http_info)




# 给对方一个反馈
msg = "I love only wangxiaojing"
skt.send(msg.encode())

skt.close()
sock.close()

---

v03-HTTP协议返回：

import socket



def getHttpHeader(skt):
'''
得到传入socket的http请求头
:param skt: 通信的socket
    :return: 解析后的请求头内容，字典形式
    '''

# 读取某一行
# 直到读取的行返回空行为止

# 用来存放结果，dict类型
rst = {}

line = getLine(skt)
while line:
'''
判断得到的行是报头还是首部行，两个操作方法不一样
        算法是：
        1. 利用‘： ’作为分隔符，分割字符串
        2. 如果是首部行，则一定会把字符串分成两个子串
        3. 否则就是一个字符串
        '''
r = line.split(r': ')

if len(r) == 2:
rst[r[0]] = r[1]
else:
r = line.split(r' ')
rst['method'] = r[0]
rst['uri'] = r[1]
rst['version'] = r[2]

line = getLine(skt)

return rst




def getLine(skt):
'''
从socket中读取某一行
:param skt: ocket
    :return:  返回读取到的一行str格式内容
    '''
'''
前提:
    1. http协议传输内容是ascii编码
    2. 真正传输的内容是通过网络流传输
    3. 回车换行： b'
', b'
', b表示是一个bytes格式
    '''
# 每次从socket读取一个byte内容
b1 = skt.recv(1)
b2 = 0
#data用来存放读取的行的内容
data = b''

#当确定还没有读到一行最后，也就是回车换行符号的时候，需要循环
while b2 != b'
' and b1 != b'
':
b2 = b1
        b1 = skt.recv(1)

data += bytes(b2)

# decode 需要一个参数，即编码，但是不给的话就采用默认utf-8解码
return data.strip(b'
').decode()



def sendRsp(skt, content):
'''
发送返回值，利用传入的socket
    :param skt: 通信的socket
    :return:
    '''

# 构建返回头
rsp_1 = "HTTP/1.1 200 OK
"
rsp_2 = "Date: 20180616
"
# 求返回内容的长度
len_value= len(content)
rsp_3 = "Content-Length: {0}
".format(len_value)
rsp_4 = "
"
rsp_content = content
# rsp代表返回的全部数据信息,里面包含http协议本身的内容
rsp = rsp_1 + rsp_2 + rsp_3 + rsp_4 + rsp_content

    skt.send(rsp.encode())



# 理解两个参数的含义
# 理解创建一个socket的过程
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 注意addr的格式是tuple
# 以及tuple两个元素的含义
sock.bind(("127.0.0.1", 7852))
print("已经绑定端口........")
# 监听
sock.listen()
print("正在监听......")

# 接受一个传进来的socket
print("准备接受socket传入....")
skt, addr = sock.accept()
print("已经接收到传入socket： {0}".format(skt))

# 实际处理请求内容
http_info = getHttpHeader(skt)
print(http_info)




# 给对方一个反馈
msg = "I love only wangxiaojing"
sendRsp(skt, msg)

skt.close()
sock.close()

---

v04-OOP重构-面向对象重构代码

import socket
import threading

class SocketHandler:

def __init__(self, sock):
self.sock = sock
# 放置Http请求的头部信息
self.headInfo = set()

def startHandler(self):
'''
处理传入请求做两件事情
        1. 解析http协议
        2. 返回n内容
:return:
        '''
self.headHandler()
self.sendRsp()
return None

def headHandler(self):
# 两个下划线开头的变量是啥意思捏？
self.headInfo = self.__getAllLine()
print(self.headInfo)
return None

def sendRsp(self):
data = "HELLO WORLD"
self.__sendRspAll(data)
return None

#####################################

def __getLine(self):

b1 = self.sock.recv(1)
b2 = 0
data = b''

while  b2 != b'
' and b1 != b'
' :
b2 = b1
            b1 = self.sock.recv(1)

data += bytes(b2)

return data.strip(b'
')


def __getAllLine(self):

data = b''
dataList = list()
data = b''

while True:
data = self.__getLine()
if data:
dataList.append(data)
else:
return dataList

        return None

def __sendRspLine(self,data):

data += "
"
self.sock.send(data.encode("ASCII"))
return None


def __sendRspAll(self, data):

self.__sendRspLine("HTTP/1.1 200 OK")

strRsp = "Content-Length: "
strRsp += str(len(data))
self.__sendRspLine( strRsp )

self.__sendRspLine("Content-Type: text/html")

self.__sendRspLine("")
self.__sendRspLine(data)


class WebServer():


def __init__(self, ip='127.0.0.1', port=7853):
self.ip = ip
self.port = port

self.sock = socket.socket( socket.AF_INET, socket.SOCK_STREAM)
self.sock.bind((self.ip, self.port))
self.sock.listen(1)
print("WebServer is started............................")

def start(self):
'''
服务器程序一共永久性不间断提供服务
:return:
        '''
while True:
skt, addr = self.sock.accept()

if skt:
print("Received a socket {0} from {1} ................. ".format(skt.getpeername(), addr))
# sockHandler负责具体通信
sockHandler = SocketHandler(skt)
thr = threading.Thread(target=sockHandler.startHandler , args=( ) )
thr.setDaemon(True)
thr.start()
thr.join()

skt.close()
print("Socket {0} handling is done............".format(addr))



if __name__ == '__main__':
ws = WebServer()
ws.start()

---

v05-配置文件

class ServerContent:
ip = '127.0.0.1'
port = 9999

head_protocal = "HTTP/1.1 "
head_code_200 = "200 "
head_status_OK = "OK"

head_content_length = "Content-Length: "
head_content_type = "Content-Type: "
content_type_html = "text/html"

blank_line = ""



import socket
import threading

class SocketHandler:

def __init__(self, sock):
self.sock = sock
# 放置Http请求的头部信息
self.headInfo = set()

def startHandler(self):
'''
处理传入请求做两件事情
        1. 解析http协议
        2. 返回n内容
:return:
        '''
self.headHandler()
self.sendRsp()
return None

def headHandler(self):
# 两个下划线开头的变量是啥意思捏？
self.headInfo = self.__getAllLine()
print(self.headInfo)
return None

def sendRsp(self):
data = "HELLO WORLD"
self.__sendRspAll(data)
return None

#####################################

def __getLine(self):

b1 = self.sock.recv(1)
b2 = 0
data = b''

while  b2 != b'
' and b1 != b'
' :
b2 = b1
            b1 = self.sock.recv(1)

data += bytes(b2)

return data.strip(b'
')


def __getAllLine(self):

data = b''
dataList = list()
data = b''

while True:
data = self.__getLine()
if data:
dataList.append(data)
else:
return dataList

        return None

def __sendRspLine(self,data):

data += "
"
self.sock.send(data.encode("ASCII"))
return None


def __sendRspAll(self, data):


self.__sendRspLine("HTTP/1.1 200 OK")

strRsp = "Content-Length: "
strRsp += str(len(data))
self.__sendRspLine( strRsp )

self.__sendRspLine("Content-Type: text/html")

self.__sendRspLine("")
self.__sendRspLine(data)


class WebServer():


def __init__(self, ip=ServerContent.ip, port=ServerContent.port):
self.ip = ip
self.port = port

self.sock = socket.socket( socket.AF_INET, socket.SOCK_STREAM)
self.sock.bind((self.ip, self.port))
self.sock.listen(1)
print("WebServer is started............................")

def start(self):
'''
服务器程序一共永久性不间断提供服务
:return:
        '''
while True:
skt, addr = self.sock.accept()

if skt:
print("Received a socket {0} from {1} ................. ".format(skt.getpeername(), addr))
# sockHandler负责具体通信
sockHandler = SocketHandler(skt)
thr = threading.Thread(target=sockHandler.startHandler , args=( ) )
thr.setDaemon(True)
thr.start()
thr.join()

skt.close()
print("Socket {0} handling is done............".format(addr))



if __name__ == '__main__':
ws = WebServer()
ws.start()

---

v06-返回静态页面-返回html页面

class ServerContent:
ip = '127.0.0.1'
port = 9999

head_protocal = "HTTP/1.1 "
head_code_200 = "200 "
head_status_OK = "OK"

head_content_length = "Content-Length: "
head_content_type = "Content-Type: "
content_type_html = "text/html"

blank_line = ""



import socket
import threading

class SocketHandler:

def __init__(self, sock):
self.sock = sock
# 放置Http请求的头部信息
self.headInfo = set()

def startHandler(self):
'''
处理传入请求做两件事情
        1. 解析http协议
        2. 返回n内容
:return:
        '''
self.headHandler()
self.sendRsp()
return None

def headHandler(self):
# 两个下划线开头的变量是啥意思捏？
self.headInfo = self.__getAllLine()
print(self.headInfo)
return None


def sendRsp(self):
data = "HELLO WORLD"
        '''
想返回一个静态页面，可以考虑把静态页面文件读入，作为str类型
        然后作为一共长字符串返回
        '''

fp = r'.webapphello.html'

with  open(fp, mode='r', encoding='utf-8') as f:
data = f.read()
self.__sendRspAll(data)

return None

#####################################

def __getLine(self):

b1 = self.sock.recv(1)
b2 = 0
data = b''

while  b2 != b'
' and b1 != b'
' :
b2 = b1
            b1 = self.sock.recv(1)

data += bytes(b2)

return data.strip(b'
')


def __getAllLine(self):

data = b''
dataList = list()
data = b''

while True:
data = self.__getLine()
if data:
dataList.append(data)
else:
return dataList

        return None

def __sendRspLine(self,data):

data += "
"
self.sock.send(data.encode())
return None


def __sendRspAll(self, data):


self.__sendRspLine("HTTP/1.1 200 OK")

strRsp = "Content-Length: "
strRsp += str(len(data))
self.__sendRspLine( strRsp )

self.__sendRspLine("Content-Type: text/html")

self.__sendRspLine("")
self.__sendRspLine(data)


class WebServer():


def __init__(self, ip=ServerContent.ip, port=ServerContent.port):
self.ip = ip
self.port = port

self.sock = socket.socket( socket.AF_INET, socket.SOCK_STREAM)
self.sock.bind((self.ip, self.port))
self.sock.listen(1)
print("WebServer is started............................")

def start(self):
'''
服务器程序一共永久性不间断提供服务
:return:
        '''
while True:
skt, addr = self.sock.accept()

if skt:
print("Received a socket {0} from {1} ................. ".format(skt.getpeername(), addr))
# sockHandler负责具体通信
sockHandler = SocketHandler(skt)
thr = threading.Thread(target=sockHandler.startHandler , args=( ) )
thr.setDaemon(True)
thr.start()
thr.join()

skt.close()
print("Socket {0} handling is done............".format(addr))



if __name__ == '__main__':
ws = WebServer()
ws.start()

webapp:hello.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>北京图灵学院欢迎您</title>
</head>
<body>

<h1 style="color:blue"> 我爱北京图灵学院刘大拿</h1>

</body>
</html>

---

v07-添加路由：

class ServerContent:
ip = '127.0.0.1'
port = 9999

head_protocal = "HTTP/1.1 "
head_code_200 = "200 "
head_status_OK = "OK"

head_content_length = "Content-Length: "
head_content_type = "Content-Type: "
content_type_html = "text/html"

blank_line = ""



import socket
import threading

class SocketHandler:

def __init__(self, sock):
self.sock = sock
# 放置Http请求的头部信息
self.headInfo = dict()

def startHandler(self):
'''
处理传入请求做两件事情
        1. 解析http协议
        2. 返回n内容
:return:
        '''
self.headHandler()
self.reqRoute()
return None

def reqRoute(self):

uri = self.headInfo.get("uri")
if uri == b"/":
self.sendRsp(r"./webapp/hello.html")
return None
if uri == b"/favicon.ico":
self.sendStaticIco(r"./static/fav.jfif")
return None

self.sendRsp(r"./webapp/404.html")

def sendStaticIco(self, fp):
with open(fp, mode='rb') as f:
ico = f.read()
self.__sendRspAll(ico)

def headHandler(self):
self.headInfo = dict()
tmpHead = self.__getAllLine()
for line in tmpHead:
if b":" in line:
# split的具体含义
infos = line.split(b": ")
self.headInfo[infos[0]] = infos[1]
else:
infos = line.split(b" ")
self.headInfo["protocal"] = infos[2]
self.headInfo["method"] = infos[0]
self.headInfo["uri"] = infos[1]


def sendRsp(self, fp):
data = "HELLO WORLD"
        '''
想返回一个静态页面，可以考虑把静态页面文件读入，作为str类型
        然后作为一共长字符串返回
        '''

#r'.webapphello.html'

with  open(fp, mode='r', encoding='utf-8') as f:
data = f.read()
self.__sendRspAll(data)

return None

#####################################

def __getLine(self):

b1 = self.sock.recv(1)
b2 = 0
data = b''

while  b2 != b'
' and b1 != b'
' :
b2 = b1
            b1 = self.sock.recv(1)

data += bytes(b2)

return data.strip(b'
')


def __getAllLine(self):

data = b''
dataList = list()
data = b''

while True:
data = self.__getLine()
if data:
dataList.append(data)
else:
return dataList

        return None

def __sendRspLine(self,data):

if type(data) == bytes:
self.sock.send(data)
else:
data += "
"
self.sock.send(data.encode())
return None


def __sendRspAll(self, data):


self.__sendRspLine("HTTP/1.1 200 OK")

strRsp = "Content-Length: "
strRsp += str(len(data))
self.__sendRspLine( strRsp )

self.__sendRspLine("Content-Type: text/html")

self.__sendRspLine("")
self.__sendRspLine(data)


class WebServer():


def __init__(self, ip=ServerContent.ip, port=ServerContent.port):
self.ip = ip
self.port = port

self.sock = socket.socket( socket.AF_INET, socket.SOCK_STREAM)
self.sock.bind((self.ip, self.port))
self.sock.listen(1)
print("WebServer is started............................")

def start(self):
'''
服务器程序一共永久性不间断提供服务
:return:
        '''
while True:
skt, addr = self.sock.accept()

if skt:
print("Received a socket {0} from {1} ................. ".format(skt.getpeername(), addr))
# sockHandler负责具体通信
sockHandler = SocketHandler(skt)
thr = threading.Thread(target=sockHandler.startHandler , args=( ) )
thr.setDaemon(True)
thr.start()
thr.join()

skt.close()
print("Socket {0} handling is done............".format(addr))



if __name__ == '__main__':
ws = WebServer()
ws.start()

 

 

 

 

 

 

<wiz_tmp_tag id="wiz-table-range-border" contenteditable="false" style="display: none;">

 

 

 

 

来自为知笔记(Wiz)