socket套接字编程
套接字介绍
1. 套接字 ： 实现网络编程进行数据传输的一种技术手段
2. Python实现套接字编程：import socket
3. 套接字分类
>流式套接字(SOCK_STREAM): 以字节流方式传输数据，实现tcp网络传输方案。(面向连接--tcp协议--可靠的--流式套接字)
>数据报套接字(SOCK_DGRAM):以数据报形式传输数据，实现udp网络传输方案。(无连接--udp协议--不可靠--数据报套接字)
tcp套接字编程
服务端流程
from socket import * #创建流式套接字
sockfd = socket(AF_INET,SOCK_STREAM,0) #绑定ＩＰ端口
sockfd.bind(('127.0.0.1',8888)) #设置监听套接字，创建监听队列
sockfd.listen(5) while True:
print("waiting for connect....")
#等待客户端链接
connfd,addr = sockfd.accept()
print("connect from",addr) while True:
#收发消息 data = connfd.recv(1024) if not data:
break print(data.decode()) #发消息
connfd.send('来,确认下眼神'.encode())
#关闭套接字
connfd.close() sockfd.close()
TCP_server.py
1. 创建套接字
sockfd=socket.socket(socket_family=AF_INET,socket_type=SOCK_STREAM,proto=0)
功能：创建套接字
参数： socket_family 网络地址类型 AF_INET表示ipv4
socket_type 套接字类型 SOCK_STREAM(流式) SOCK_DGRAM(数据报)
proto 通常为0 选择子协议
返回值： 套接字对象
2. 绑定地址
>本地地址 ： 'localhost' , '127.0.0.1'
>网络地址 ： '172.40.91.185'
>自动获取地址： '0.0.0.0'
sockfd.bind(addr)
功能： 绑定本机网络地址
参数： 二元元组 (ip,port) ('0.0.0.0',8888)
```
3. 设置监听
sockfd.listen(n)
功能 ： 将套接字设置为监听套接字，确定监听队列大小
参数 ： 监听队列大小
```
4. 等待处理客户端连接请求
connfd,addr = sockfd.accept()
功能： 阻塞等待处理客户端请求
返回值： connfd 客户端连接套接字
addr 连接的客户端地址
```
5. 消息收发
data = connfd.recv(buffersize)
功能 : 接受客户端消息
参数 ：每次最多接收消息的大小
返回值： 接收到的内容
n = connfd.send(data)
功能 : 发送消息
参数 ：要发送的内容 bytes格式
返回值： 发送的字节数
```
6. 关闭套接字
sockfd.close()
功能：关闭套接字
```
客户端流程
# 接受的客户端 from socket import * #创建套接字
sockfd = socket(AF_INET,SOCK_STREAM) #发起连接
sockfd.connect(('127.0.0.1',8888)) while True:
msg = input("发消息>> ")
#发送消息
sockfd.send(msg.encode())
if not msg:
break #接收消息
data = sockfd.recv(1024)
print(data.decode()) # msg = input("Msg>>")
# scorfd.send(msg.encode()) # data = sockfd.recv(1024)
# print(data.decode()) #关闭
sockfd.close()
TCP_client.py
1. 创建套接字
>注意:只有相同类型的套接字才能进行通信
2. 请求连接
sockfd.connect(server_addr)
功能：连接服务器
参数：元组 服务器地址
3. 收发消息
>注意： 防止两端都阻塞，recv send要配合
4. 关闭套接字
tcp 套接字数据传输特点
>* tcp连接中当一端退出，另一端如果阻塞在recv，此时recv会立即返回一个空字串。
>* tcp连接中如果一端已经不存在，仍然试图通过send发送则会产生BrokenPipeError
>* 一个监听套接字可以同时连接多个客户端，也能够重复被连接
网络收发缓冲区
1. 网络缓冲区有效的协调了消息的收发速度
2. send和recv实际是向缓冲区发送接收消息，当缓冲区不为空recv就不会阻塞。
tcp粘包
socket.time.sleep(0.1)
>原因：tcp以字节流方式传输，没有消息边界。多次发送的消息被一次接收，此时就会形成粘包。
>影响：如果每次发送内容是一个独立的含义，需要接收端独立解析此时粘包会有影响。
>处理方法
>>1. 人为的添加消息边界
>>2. 控制发送速度
UDP套接字编程
服务端流程
from socket import *
import sys
from time import ctime ADDR = ('127.0.0.1',8888)
BUFFERSIZE = 1024 #创建数据报套接字
sockfd = socket(AF_INET,SOCK_DGRAM)
#绑定地址
sockfd.bind(ADDR) #收发消息
while True:
data,addr = sockfd.recvfrom(BUFFERSIZE)
print('recv from %s:%s'%(addr,data.decode()))
sockfd.sendto\
(("[%s] 接收到消息"%ctime()).encode(),addr) sockfd.close() #服务端， udp
from socket import * HOST = '127.0.0.1'
PORT = 9999
ADDR = (HOST, PORT)
#创建数据报套接字
sockfd = socket(AF_INET,SOCK_DGRAM)
#绑定地址
sockfd.bind(ADDR)
#收发消息
while True:
data,addr = sockfd.recvfrom(1024)
print('Receive from %s:%s' % (addr,data.decode()))
# sockfd.sendto(("[%s] 接收到消息"%ctime()).encode(),addr)
sockfd.sendto("收到消息".encode(), addr)
sockfd.close()
UDP_server.py
1. 创建数据报套接字
sockfd = socket(AF_INET,SOCK_DGRAM)
2. 绑定地址
sockfd.bind(addr)
3. 消息收发
data,addr = sockfd.recvfrom(buffersize)
功能： 接收UDP消息
参数： 每次最多接收多少字节
返回值： data 接收到的内容
addr 消息发送方地址
n = sockfd.sendto(data,addr)
功能： 发送UDP消息
参数： data 发送的内容 bytes格式
addr 目标地址
返回值：发送的字节数
4. 关闭套接字
sockfd.close()
客户端流程
from socket import *
import sys #从命令行传入ＩＰ和端口
#python3 udp_server.py 172.60.50.42 8888
if len(sys.argv) < 3:
print('''
argv is error!!!
input as
python3 udp_server.py 172.60.50.42 4260
''') HOST = sys.argv[1]
PORT = int(sys.argv[2])
ADDR = (HOST,PORT)
BUFFERSIZE = 1024 #创建数据报套接字
sockfd = socket(AF_INET,SOCK_DGRAM) while True:
data = input("消息>>")
#直接回车退出
if not data:
break
sockfd.sendto(data.encode(),ADDR)
data,addr = sockfd.recvfrom(BUFFERSIZE)
print('从服务器收到：',data.decode())
sockfd.close() #客户端
from socket import *
import sys #命令行输入服务器地址
if len(sys.argv) < 3:
print('''argv is error !!
start as
python3 udp_client.py 127.0.0.1 8888
''')
# raise HOST = sys.argv[1]
PORT = int(sys.argv[2])#字符串转int类型
ADDR = (HOST,PORT) #创建数据报套接字
sockfd = socket(AF_INET, SOCK_DGRAM) while True:
data = input("消息: ")
if not data:
break
sockfd.sendto(data.encode(),ADDR)
data,addr = sockfd.recvfrom(1024)
print("从服务端收到： ", data.decode()) sockfd.close() # $ python3 udp_client.py 127.0.0.1 8888
#要加ip名和端口名才能运行
UDP_client.py
1. 创建套接字
2. 收发消息
3. 关闭套接字
---------------
>总结 ：tcp套接字和udp套接字编程区别
>>1. 流式套接字是以字节流方式传输数据，数据报套接字以数据报形式传输
>>2. tcp套接字会有粘包，udp套接字有消息边界不会粘包
>>3. tcp套接字保证消息的完整性，udp套接字则不能
>>4. tcp套接字依赖listen accept建立连接才能收发消息，udp套接字则不需要
>>5. tcp套接字使用send，recv收发消息，udp套接字使用sendto，recvfrom
---------------------
socket套接字属性
【1】 sockfd.type 套接字类型
【2】 sockfd.family 套接字地址类型
【3】 sockfd.getsockname() 获取套接字绑定地址
【4】 sockfd.fileno() 获取套接字的文件描述符
【5】 sockfd.getpeername() 获取连接套接字客户端地址
【6】 sockfd.setsockopt(level,option,value)
功能：设置套接字选项
参数： level 选项类别 SOL_SOCKET
option 具体选项内容
value 选项值
【7】 sockfd.getsockopt(level,option)
功能 ： 获取套接字选项值
UDP套接字广播
#广播接收端 与udp的 from socket import * HOST = ''
PORT = 8880 #创建数据报套接字
s = socket(AF_INET,SOCK_DGRAM)#加默认参数0变成流式套接字SOCK_STREAM
#固定接收端的端口号
s.bind((HOST,PORT))
#设置套接字可以接收广播， 有此后变成与udp不同
s.setsockopt(SOL_SOCKET,SO_BROADCAST,1)#broadcast
#设置套接字保护端口号
s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)#reuseaddr # while True:
# try:
# message,addr = s.recvfrom(1024)
# print("从{}获取信息{}:".\
# format(addr,message.decode()))#decode将“字节流”按照某种规则转换成'文本' str变unicode
# s.sendto(b"I am here",addr)
# except (KeyboardInterrupt,SyntaxError):#从终端ctrl+c的错
# raise
# except Exception as e:
# print(e) # s.close() while True:
try:
message,addr = s.recvfrom(1024)
print("获取信息: {}".\
format(message.decode()))#decode将“字节流”按照某种规则转换成'文本' str变unicode
s.sendto(b"I am here",addr)
except (KeyboardInterrupt,SyntaxError):#从终端ctrl+c的错
raise#raise 引发一个异常
except Exception as e:#异常类
print(e) s.close()
broadcast_recv.py
# 发送端 from socket import *
from time import sleep #发送广播的地址
#<broadcast>
dest = ('176.122.14.255',8880)#端口号9999一致
#创建数据报套接字
s = socket(AF_INET,SOCK_DGRAM)#dgram
#设置能够发送广播
s.setsockopt(SOL_SOCKET,SO_BROADCAST,1)#broadcast while True:
sleep(2)
s.sendto("什么鬼啊aaaaaa啦啦啦啦啦啦啦".encode(),dest)#目标地址
data,addr = s.recvfrom(1024)
print("Received from %s:%s"%(addr,data.decode()))
s.close() # while True:
# data = input('input: ')
# s.sendto(("@鸿182："+ data).encode(),dest)
# s.close()
# 局域网聊天室，同端口号
broadcast_send.py
* 广播定义 ： 一端发送多点接收
* 广播地址 ： 每个网络的最大地址为发送广播的地址，向该地址发送，则网段内所有主机都能接收。
TCP套接字之HTTP传输
HTTP协议 （超文本传输协议）
1. 用途 ： 网页获取，数据的传输
2. 特点
应用层协议，传输层使用tcp传输
简单，灵活，很多语言都有HTTP专门接口
无状态，协议不记录传输内容
http1.1 支持持久连接，丰富了请求类型
3. 网页请求过程
1.客户端（浏览器）通过tcp传输，发送http请求给服务端
2.服务端接收到http请求后进行解析
3.服务端处理请求内容，组织响应内容
4.服务端将响应内容以http响应格式发送给浏览器
5.浏览器接收到响应内容，解析展示
HTTP请求（request）
"""
httpserver v2.0
env: python3.6
io多路复用 和 http训练
""" from socket import *
from select import * # 具体功能实现
class HTTPServer:
def __init__(self, host='0.0.0.0', port=8000, dir=None):
self.host = host
self.port = port
self.dir = dir
self.address = (host, port)
# 多路复用列表
self.rlist = []
self.wlist = []
self.xlist = []
# 实例化对象时直接创建套接字
self.create_socket()
self.bind() # 创建套接字
def create_socket(self):
self.sockfd = socket()
self.sockfd.setsockopt(SOL_SOCKET,
SO_REUSEADDR, 1) # 绑定地址
def bind(self):
self.sockfd.bind(self.address) # 启动服务
def serve_forever(self):
self.sockfd.listen(3)
print("Listen the port %d" % self.port)
# IO多路复用接收客户端请求
self.rlist.append(self.sockfd)
while True:
rs, wx, xs = select(self.rlist,
self.wlist,
self.xlist)
for r in rs:
if r is self.sockfd:
c, addr = r.accept()
self.rlist.append(c)
else:
# 处理请求
self.handle(r) def handle(self, connfd):
# 接收HTTP请求
request = connfd.recv(4096)
# 客户端断开
if not request:
self.rlist.remove(connfd)
connfd.close()
return
# 提取请求内容 (字节串按行分割)
request_line = request.splitlines()[0]
info = request_line.decode().split(' ')[1]
print(connfd.getpeername(), ':', info) # 根据请求内容进行数据整理
# 分为两类 1.请求网页 2.其他
if info == '/' or info[-5:] == '.html':
self.get_html(connfd, info)
else:
self.get_data(connfd, info) # 返回网页
def get_html(self, connfd, info):
if info == '/':
# 请求主页
filename = self.dir + "/index.html"
else:
filename = self.dir + info
try:
fd = open(filename)
except Exception:
# 网页不存在
response = "HTTP/1.1 404 Not Found\r\n"
response += 'Content-Type:text/html\r\n'
response += '\r\n'
response += '<h1>Sorry....</h1>'
else:
# 网页存在
response = "HTTP/1.1 200 OK\r\n"
response += 'Content-Type:text/html\r\n'
response += '\r\n'
response += fd.read()
finally:
# 将响应发送给浏览器
connfd.send(response.encode()) # 其他数据
def get_data(self, connfd, info):
response = "HTTP/1.1 200 OK\r\n"
response += 'Content-Type:text/html\r\n'
response += '\r\n'
response += "<h1>Waiting for httpserver 3.0</h1>"
connfd.send(response.encode()) # 用户使用HTTPServer
if __name__ == "__main__":
"""
通过 HTTPServer类快速搭建服务，展示自己的网页
"""
# 用户决定的参数
HOST = '0.0.0.0'
PORT = 8000
DIR = './static' # 网页存储位置 httpd = HTTPServer(HOST, PORT, DIR) # 实例化对象
httpd.serve_forever() # 启动服务
HTTP_server.py
#静态网页处理器
#采用循环的模式，无法满足客户端长连接 from socket import *#网络连接端点,导入模块 #处理客户端请求, 交互
def handleClient(connfd):#请求，调用函数
request = connfd.recv(2048)#请求套接字接受文件
# print('**************')
# print(request)
# print('**************')
#按照行切割请求， 方便查看
request_lines = request.splitlines()
for line in request_lines:
print(line.decode())#对分割后的文件解码 try:
f = open("index.html")
except IOError:#找不到页面， 文件出错
response = "HTTP/1.1 303 not Found\r\n"#http响应行
response += '\r\n'#无响应头， 有空行
response += '''====sorry ,file not find
*******************************
Sorry bing i love you miss you.
*******************************
'''
else:#正常情况运行
response = "HTTP/1.1 200 OK\r\n"#成功响应头， 响应体是页面
response += '\r\n'
response += f.read()#响应体是页面
# for i in f:
# response += i
finally:
connfd.send(response.encode())#发送给浏览器
connfd.close() #流程控制
def main():
sockfd = socket()#创建流式套接字
sockfd.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)#设置端口重用
sockfd.bind(('0.0.0.0',8888))#绑定套接字
sockfd.listen(10)#监听套接字
while True:#循环监听等待连接
print("Listen the port 8000..")
connfd,addr = sockfd.accept()#创建另一个套接字连接请求，便于接收一个后再接收，
#处理浏览器发来的请求
handleClient(connfd)#跟客户顿交互
connfd.close()#关闭套接字 if __name__ == "__main__":#调用主函数
main() # --------------------------------------------------------------- # #接收请求
# #查看请求
# #返回客户端请求 # def handleClient():
# pass # #创建tcp套接字， 调用handleClient完成功能
# def main():
# pass # if __name__=="__main__":
# main()
HTTP_server.py
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>欢迎进入Alan主页</title>
</head>
<body>
<h1>Alan songzihong welcome to you </h1>
<h1>what is you name</h1>
<h1>How can i do cna help you </h1>
</body>
</html> <!-- 没保存会只显示文件名 -->
<!-- html:5 + tab -->
<!-- h1 + tab -->
index.html
* 请求行 ： 具体的请求类别和请求内容
```
GET / HTTP/1.1
请求类别 请求内容 协议版本
```
请求类别：每个请求类别表示要做不同的事情
```
GET : 获取网络资源
POST ：提交一定的信息，得到反馈
HEAD ： 只获取网络资源的响应头
PUT ： 更新服务器资源
DELETE ： 删除服务器资源
CONNECT
TRACE ： 测试
OPTIONS ： 获取服务器性能信息
```
* 请求头：对请求的进一步解释和描述
```
Accept-Encoding: gzip
```
* 空行
* 请求体: 请求参数或者提交内容
http响应（response）
1. 响应格式：响应行，响应头，空行，响应体
* 响应行 ： 反馈基本的响应情况
```
HTTP/1.1 200 OK
版本信息 响应码 附加信息
```
响应码 ：
```
1xx 提示信息，表示请求被接收
2xx 响应成功
3xx 响应需要进一步操作，重定向
4xx 客户端错误
5xx 服务器错误
```
* 响应头：对响应内容的描述
```
Content-Type: text/html
```
* 响应体：响应的主体内容信息