socket编程
1. socket???
-
socket(ip:port): Unix -> (Linux,IOS) ----> 一切皆文件 ----> socket也是一种特殊的文件;
打开文件(open) -> 读写(read/write) -> 关闭文件(close) -
socket模块: TCP/IP协议族的封装, 把应用层和TCP/IP协议族通信的中间软件抽象出来.
2. TCP协议+UDP协议?
TCP(transfer control protocol): 传输控制协议, ,面向连接(TCP的三次握手四次分手);
UDP(user data protocol): 用户数据报协议, 无连接的协议;
基于TCP通信
- TCP工作方式
- client
import socket
# 1. 创建一个socket对象;
# family指定使用IP协议的版本: IPV4:AF_INET; ipv6: AF_INET6
# type指定传输层使用的协议类型:TCP(SOCKET.SOCK_STREAM), UDP(SOCK_DGRAM)
client = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
# 2. 连接服务端(ip, port)
client.connect(('172.25.60.250', 4002))
# 3. 给服务端回复消息, send(self, data: **bytes***, flags: int = ...) -> int: ...
client.send("你好, 服务端".encode('utf-8'))
# 4. 接收服务端回复的消息
recvData = client.recv(1024)
print("客户端接收的消息:", recvData.decode('utf-8'))
# 7. 关闭客户端socket对象
client.close()
- server
import socket
# 1. 创建一个socket对象;
# family指定使用IP协议的版本: IPV4:AF_INET; ipv6: AF_INET6
# type指定传输层使用的协议类型:TCP(SOCKET.SOCK_STREAM), UDP(SOCK_DGRAM)
server = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
# 2. 绑定一个IP和端口, 供客户端来连接;
server.bind(('172.25.60.250', 4002))
# 3. 监听是否有客户端连接
server.listen(5)
print("服务端正在启动.........")
# 4. 接收客户端的连接, accept() -> (socket object, address info)
clientSocket, address = server.accept()
print("客户端的地址:", address)
# 5. 接收客户端发送的消息
recvData = clientSocket.recv(1024)
print("服务端接收的消息:", recvData.decode('utf-8'))
# 6. 给客户端回复消息, send(self, data: **bytes***, flags: int = ...) -> int: ...
clientSocket.send('你好, 客户端'.encode('utf-8'))
# 7. 关闭服务端socket对象
server.close()
clientSocket.close()
基于TCP的聊天式通信
- server
import socket
# 1. 创建一个socket对象;
# family指定使用IP协议的版本: IPV4:AF_INET; ipv6: AF_INET6
# type指定传输层使用的协议类型:TCP(SOCKET.SOCK_STREAM), UDP(SOCK_DGRAM)
server = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
# 2. 绑定一个IP和端口, 供客户端来连接;
server.bind(('172.25.60.250', 4656))
# 3. 监听是否有客户端连接
server.listen(5)
print("服务端正在启动.........")
# 4. 接收客户端的连接, accept() -> (socket object, address info)
clientSocket, address = server.accept()
print("客户端的地址:", address)
while True:
# 5. 接收客户端发送的消息
recvData = clientSocket.recv(1024)
print("服务端接收的消息:", recvData.decode('utf-8'))
# 6. 给客户端回复消息, send(self, data: **bytes***, flags: int = ...) -> int: ...
sendData = input('server:>> ')
if not sendData:
continue
if sendData == 'quit':
print("聊天结束.....")
break
clientSocket.send(sendData.encode('utf-8'))
# 7. 关闭服务端socket对象
server.close()
clientSocket.close()
- client
import socket
# 1. 创建一个socket对象;
# family指定使用IP协议的版本: IPV4:AF_INET; ipv6: AF_INET6
# type指定传输层使用的协议类型:TCP(SOCKET.SOCK_STREAM), UDP(SOCK_DGRAM)
client = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
# 2. 连接服务端(ip, port)
client.connect(('172.25.60.250', 4656))
while True:
# 3. 给服务端回复消息, send(self, data: **bytes***, flags: int = ...) -> int: ...
sendData = input('client:>> ')
if not sendData:
continue
if sendData == 'quit':
print("聊天结束.....")
break
client.send(sendData.encode('utf-8'))
# 4. 接收服务端回复的消息
recvData = client.recv(1024)
print("客户端接收的消息:", recvData.decode('utf-8'))
# 7. 关闭客户端socket对象
client.close()
基于多线程TCP的聊天式通信
- server
import os
import threading
from multiprocessing import Process
def get_client_conn(clientSocket, address):
while True:
# 5. 接收客户端发送的消息
recvData = clientSocket.recv(1024).decode('utf-8')
print("服务端接收的消息:", recvData, '\n')
# 6. 给客户端回复消息, send(self, data: **bytes***, flags: int = ...) -> int: ...
# sendData = input('server:>> ')
# if not sendData:
# continue
# if sendData == 'quit':
# print("聊天结束.....")
# break
# sendData = recvData.upper()
# os.system不能保存命令的执行结果;
sendData = os.popen(recvData).read()
clientSocket.send(sendData.encode('utf-8'))
clientSocket.close()
import socket
# 1. 创建一个socket对象;
# family指定使用IP协议的版本: IPV4:AF_INET; ipv6: AF_INET6
# type指定传输层使用的协议类型:TCP(SOCKET.SOCK_STREAM), UDP(SOCK_DGRAM)
server = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
# 2. 绑定一个IP和端口, 供客户端来连接;
server.bind(('172.25.60.250', 4008))
# 3. 监听是否有客户端连接
server.listen(5)
print("服务端正在启动.........")
while True:
# 4. 接收客户端的连接, accept() -> (socket object, address info)
clientSocket, address = server.accept()
print("客户端的地址:", address)
# 使用多进程
t = Process(target=get_client_conn, args=(clientSocket, address))
t.start()
- client1
import socket
# 1. 创建一个socket对象;
# family指定使用IP协议的版本: IPV4:AF_INET; ipv6: AF_INET6
# type指定传输层使用的协议类型:TCP(SOCKET.SOCK_STREAM), UDP(SOCK_DGRAM)
client = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
# 2. 连接服务端(ip, port)
client.connect(('172.25.60.250', 4008))
while True:
# 3. 给服务端回复消息, send(self, data: **bytes***, flags: int = ...) -> int: ...
sendData = input('client:>> ')
if not sendData:
continue
if sendData == 'quit':
print("聊天结束.....")
break
client.send(sendData.encode('utf-8'))
# 4. 接收服务端回复的消息
recvData = client.recv(1024)
print("客户端接收的消息:", recvData.decode('utf-8'))
# 7. 关闭客户端socket对象
client.close()
- client2
import socket
# 1. 创建一个socket对象;
# family指定使用IP协议的版本: IPV4:AF_INET; ipv6: AF_INET6
# type指定传输层使用的协议类型:TCP(SOCKET.SOCK_STREAM), UDP(SOCK_DGRAM)
client = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
# 2. 连接服务端(ip, port)
client.connect(('172.25.60.250', 4008))
while True:
# 3. 给服务端回复消息, send(self, data: **bytes***, flags: int = ...) -> int: ...
sendData = input('client:>> ')
if not sendData:
continue
if sendData == 'quit':
print("聊天结束.....")
break
client.send(sendData.encode('utf-8'))
# 4. 接收服务端回复的消息
recvData = client.recv(1024)
print("客户端接收的消息:", recvData.decode('utf-8'))
# 7. 关闭客户端socket对象
client.close()
基于UDP通信
- 工作方式
- server
import socket
# 1. 实例化socket对象
udpServer = socket.socket(family=socket.AF_INET,type=socket.SOCK_DGRAM)
# 2. 绑定IP和端口
# 172.25.254.250
# 0.0.0.0代表开放所有的IP地址
udpServer.bind(('0.0.0.0', 9001))
print("等待客户端UDP的连接.....")
# 3. 接收客户端的连接
recvdata, address = udpServer.recvfrom(1024)
print("接收到客户端的数据: ", recvdata.decode('utf-8'))
# 4. 给客户端回复消息
udpServer.sendto(b"hello client", address)
# 5. 关闭socket对象
udpServer.close()
- client
import socket
udpClient = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)
udpClient.sendto(b'hello server', ('172.25.60.250', 9001))
recvData, address = udpClient.recvfrom(1024)
print("接收服务端的数据: ", recvData.decode('utf-8'))
udpClient.close()
基于多线程UDP通信
- server
import socket
import os
import threading
def job(cmd,address):
# cmd, address = udpServer.recvfrom(1024)
# cmd = cmd.decode('utf-8')
print("接收到客户端%s的命令: %s" %(address, cmd.decode('utf-8')))
# 4. 给客户端回复消息
cmdRes = os.popen(cmd.decode('utf-8')).read().encode('utf-8')
udpServer.sendto(cmdRes, address)
# 1. 实例化socket对象
udpServer = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)
# 2. 绑定IP和端口
# 172.25.254.250
# 0.0.0.0代表开放所有的IP地址
udpServer.bind(('0.0.0.0', 9009))
print("等待客户端UDP的连接.....")
while True:
# 3. 接收客户端的连接
clientData,clientAddr = udpServer.recvfrom(1024)
if not clientData:
break
t = threading.Thread(target=job,args=(clientData,clientAddr))
t.start()
- client1
import socket
udpClient = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)
while True:
cmd = input("client:>> ").encode('utf-8')
if not cmd:
continue
if cmd == 'quit':
print("正在退出....")
break
udpClient.sendto(cmd, ('172.25.60.250', 9002))
recvData, address = udpClient.recvfrom(1024)
print("接收服务端的数据: ", recvData.decode('utf-8'))
udpClient.close()
- client2
import socket
udpClient = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)
while True:
cmd = input("client1:>> ").encode('utf-8')
if not cmd:
continue
if cmd == 'quit':
print("正在退出....")
break
udpClient.sendto(cmd, ('172.25.60.250', 9002))
recvData, address = udpClient.recvfrom(1024)
print("接收服务端的数据: ", recvData.decode('utf-8'))
udpClient.close()
模拟urllib实现网页内容获取
# 实现http客户端的程序, 获取百度页面
import socket
# http://www.baidu.com:80
# 实例化socket对象; 默认参数指定为IPv4协议, 和TCP传输协议;
client = socket.socket()
# 连接服务器端
client.connect(('www.baidu.com', 80))
# 给百度服务器发送请求通过GET方法请求主页内容的请求, http协议的版本为1.1;
client.send(b'GET / HTTP/1.1\r\nHost:www.baidu.com\r\nConnection:close\r\n\r\n')
# 接收服务端返回的页面内容;
recvData = client.recv(1024*100)
# 解码为能够识别的字符串;
print(recvData.decode('utf-8'))
# 关闭客户端连接;
client.close()
实现简易Web服务器
import socket
import threading
def handler(clientObj):
# 5. 接收客户端发送的请求
recvData = clientObj.recv(1024)
with open('hello.html', 'rb') as f:
sendData = f.read()
# 告诉浏览器http版本
clientObj.send(b'HTTP/1.1 200 ok\r\n\r\n')
clientObj.send(sendData)
def webServer():
# 1. 创建socket对象
server = socket.socket()
# 2. 绑定端口和ip
server.bind(('0.0.0.0', 8080))
# 3. 监听是否有客户端连接
server.listen(5)
print("http服务正在启动8080........")
while True:
# 4. 接收客户端的连接
clientObj, address = server.accept()
t = threading.Thread(target=handler, args=(clientObj, ))
t.start()
server.close()
if __name__ == '__main__':
webServer()
socketserver
1. What is socketserver?
socket并不能多并发,只能支持一个用户,socketserver 简化了编写网络服务程序的任务,
socketserver是socket的在封装。socketserver在python2中为SocketServer,在python3
取消了首字母大写,改名为socketserver。socketserver中包含了两种类,一种为服务类(server
class),一种为请求处理类(request handle class)。前者提供了许多方法:像绑定,监听,运行……
(也就是建立连接的过程) 后者则专注于如何处理用户所发送的数据(也就是事务逻辑)。一般情况下,所有
的服务,都是先建立连接,也就是建立一个服务类的实例,然后开始处理用户请求,也就是建立一个请求处理类
的实例。
2. what types?
class socketserver.TCPServer(server_address, RequestHandlerClass, bind_and_activate=True)
class socketserver.UDPServer(server_address, RequestHandlerClass, bind_and_activate=True)
class socketserver.UnixStreamServer(server_address, RequestHandlerClass, bind_and_activate=True)
class socketserver.UnixDatagramServer(server_address, RequestHandlerClass,bind_and_activate=True)
3. How use socketserver?
- 1). 创建一个请求处理的类,并且这个类要继承 BaseRequestHandlerclass ,并且还要重写父类里handle()方法;
- 2). 你必须实例化 TCPServer,并且传递server IP和你上面创建的请求处理类,给这个TCPServer;
- 3).server.handle_requese()#只处理一个请求,server.server_forever()处理多个请求,永远执行
- 4). 关闭连接server_close()
4. Example?
- server
BUFFERSIZE=1024*2
import socketserver
from socketserver import BaseRequestHandler
import multiprocessing
import threading
class MyTcpHandler(BaseRequestHandler):
def handle(self):
# the request as self.request ==== clientSock
# client address as self.client_address
# the server as self.server
while True:
self.data = self.request.recv(BUFFERSIZE) # 获取客户端传递的数据;
print("{0} 传输数据 {1}".format(self.client_address, self.data))
self.request.send(self.data.upper())
if __name__ == "__main__":
HOST = '172.25.60.250'
PORT = 5003
# 1. 普通的服务端;
# server = socketserver.TCPServer((HOST, PORT), MyTcpHandler)
server = socketserver.ThreadingTCPServer((HOST, PORT), MyTcpHandler)
# server = socketserver.ForkingTCPServer((HOST, PORT), MyTcpHandler)
server.serve_forever()
- client1
import socket
# 1. 创建一个socket对象;
# family指定使用IP协议的版本: IPV4:AF_INET; ipv6: AF_INET6
# type指定传输层使用的协议类型:TCP(SOCKET.SOCK_STREAM), UDP(SOCK_DGRAM)
client = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
# 2. 连接服务端(ip, port)
client.connect(('172.25.60.250', 5003))
while True:
# 3. 给服务端回复消息, send(self, data: **bytes***, flags: int = ...) -> int: ...
sendData = input('client:>> ')
if not sendData:
continue
if sendData == 'quit':
print("聊天结束.....")
break
client.send(sendData.encode('utf-8'))
# 4. 接收服务端回复的消息
recvData = client.recv(1024)
print("客户端接收的消息:", recvData.decode('utf-8'))
# 7. 关闭客户端socket对象
client.close()
- client2