客户端/服务器架构
即C/S架构，包括
1.硬件C/S架构(打印机)
2.软件C/S架构(web服务)
美好的愿望：
最常用的软件服务器是 Web 服务器。一台机器里放一些网页或 Web 应用程序,然后启动 服务。这样的服务器的任务就是接受客户的请求,把网页发给客户(如用户计算机上的浏览器),然 后等待下一个客户请求。这些服务启动后的目标就是“永远运行下去”。虽然它们不可能实现这样的 目标,但只要没有关机或硬件出错等外力干扰,它们就能运行非常长的一段时间。
生活中的C/S架构：
老男孩是S端，所有的学员是C端
饭店是S端，所有的食客是C端
互联网中处处是C/S架构（黄色网站是服务端，你的浏览器是客户端；腾讯作为服务端为你提供视频，你得下个腾讯视频客户端才能看狗日的视频）
C/S架构与socket的关系：
我们学习socket就是为了完成C/S架构的开发
模拟打电话
服务端
import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机
phone.bind(('127.0.0.1',8000)) #绑定手机卡
phone.listen(5) #开机
print("------->")
conn,addr = phone.accept() #等电话
msg = conn.recv(1024) #收到消息
print("客户端发来的是",msg)
conn.send(msg.upper()) #发消息
conn.close()
phone.close()
客户端
import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect(('127.0.0.1',8000)) #拨通电话
phone.send("hellohgjgjgjk".encode("utf-8")) #发消息
data = phone.recv(1024)
print("收到服务端的是:",data)
phone.close()
服务端
# tcp服务端
from socket import *
ip_port = ("127.0.0.1",8080)
back_long = 5
buffer_size = 1024
tcp_sever = socket(AF_INET,SOCK_STREAM)
tcp_sever.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #解决重启服务端出现Address already in use
tcp_sever.bind(ip_port)
tcp_sever.listen(back_long)
while True: #外层循环用循环接收不同的链接
print("服务端开始运行了")
conn,addr = tcp_sever.accept()
print("双向链接是",conn)
print("客户端地址是",addr)
while True: #内层循环用来基于一次链接循环通信
try:
data = conn.recv(buffer_size)
if not data:break
print('客户端发来的消息是 ',data.decode("utf8"))
conn.send(data.upper())
except Exception:
break
conn.close()
tcp_sever.close()
客户端
# tcp客户端
from socket import *
ip_port = ("127.0.0.1", 8080)
buffer_size = 1024
tcp_client = socket(AF_INET, SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
msg = input(">>>").strip()
if not msg:continue
tcp_client.send(msg.encode("utf8"))
print("客户端已经发消息了")
data = tcp_client.recv(buffer_size)
print("收到服务端发的消息是 ",data.decode("utf8"))
tcp_client.close()
服务端解决粘包
#服务端(自定制报头)
from socket import *
import subprocess
import struct
ip_port=('127.0.0.1',8080)
back_log=5
buffer_size=1024
tcp_server=socket(AF_INET,SOCK_STREAM)
tcp_server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #解决重启服务端出现Address already in use
tcp_server.bind(ip_port)
tcp_server.listen(back_log)
while True:
conn,addr=tcp_server.accept()
print('新的客户端链接',addr)
while True:
#收
try: #客户端断开，会捕捉到异常
cmd=conn.recv(buffer_size)
if not cmd:break
print('收到客户端的命令',cmd)
#执行命令，得到命令的运行结果cmd_res
res=subprocess.Popen(cmd.decode('utf-8'),shell=True,
stderr=subprocess.PIPE,
stdout=subprocess.PIPE,
stdin=subprocess.PIPE)
err=res.stderr.read()
if err:
cmd_res=err
else:
cmd_res=res.stdout.read()
#发
if not cmd_res:
cmd_res='执行成功'.encode('utf8')
length=len(cmd_res)
data_length=struct.pack('i',length)
conn.send(data_length)
conn.send(cmd_res)
except Exception as e:
print(e)
break
客户端解决粘包
#客户端(自定制报头)
from socket import *
import struct
from functools import partial
ip_port=('127.0.0.1',8080)
buffer_size=1024
tcp_client=socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
cmd=input('>>: ').strip()
if not cmd:continue
if cmd == 'quit':break
tcp_client.send(cmd.encode('utf-8'))
#解决粘包
length_data=tcp_client.recv(4)
length=struct.unpack('i',length_data)[0] #服务端发回来的数据长度
recv_size=0
recv_msg=b''
while recv_size < length:
recv_msg += tcp_client.recv(buffer_size)
recv_size=len(recv_msg) #1024
print('命令的执行结果是 ',recv_msg.decode('utf8'))
tcp_client.close()
服务端 传文件
from socket import *
ip_port = ("127.0.0.1",8182)
back_long = 5
buffer_size = 1024
s = socket(AF_INET,SOCK_STREAM)
s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
s.bind(ip_port)
s.listen(back_long)
conn,addr = s.accept()
filesize = conn.recv(buffer_size)
filesize = int(filesize)
p_size = 0
p = b""
while p_size < filesize:
p += conn.recv(buffer_size)
p_size = len(p)
with open("b.jpg","wb") as f:
f.write(p)
conn.close()
s.close()
客户端 传文件
from socket import *
import os
ip_port = ("127.0.0.1",8182)
buffer_size = 1024
c = socket(AF_INET,SOCK_STREAM)
c.connect(ip_port)
p_size = os.stat("a.jpg").st_size
c.send(str(p_size).encode("utf8"))
with open("a.jpg","rb") as f:
for i in f:
# print(i)
c.send(i)
c.close()
服务端socketserver(解决tcp多用户交流)
import socketserver
ip_port = ("127.0.0.1",8081)
buffer_size = 1024
class MyServer(socketserver.BaseRequestHandler):
def handle(self):
print("conn is: ",self.request) #conn
print("addr is:",self.client_address) #addr
while True: #通信循环
try:
data = self.request.recv(buffer_size)
if not data:continue
print("客户端发来的消息是 ",data.decode("utf8"),self.client_address)
self.request.send(data.upper())
except Exception:
break
if __name__ == "__main__":
s = socketserver.ThreadingTCPServer(ip_port,MyServer)
s.serve_forever() #链接循环
客户端socketserver(解决tcp多用户交流)
from socket import *
ip_port = ("127.0.0.1",8081)
buffer_size = 1024
c = socket(AF_INET,SOCK_STREAM)
c.connect(ip_port)
while True:
msg = input(">>>:")
c.send(msg.encode("utf8"))
data = c.recv(buffer_size)
print("服务发来是消息是 ",data.decode())
c.close()
udp服务端
from socket import *
ip_port = ("127.0.0.1",8080)
buffer_size = 1024
udp_sever = socket(AF_INET,SOCK_DGRAM)
udp_sever.bind(ip_port)
while True:
data,addr = udp_sever.recvfrom(buffer_size)
print("客户端发来的是 ",data.decode("utf8"))
print("发消息来客户端的地址和端口是 ",addr)
udp_sever.sendto(data.upper(),addr)
udp客户端
from socket import *
ip_port = ("127.0.0.1",8080)
buffer_size = 1024
udp_client = socket(AF_INET,SOCK_DGRAM)
while True:
msg = input(">>>").strip()
udp_client.sendto(msg.encode("utf8"),ip_port)
data,addr = udp_client.recvfrom(buffer_size)
print("服务端发回的消息是 ",data.decode("utf8"))
udp服务端1
from socket import *
import time
ip_port = ("127.0.0.1",8080)
buffer_size = 1024
udp_sever = socket(AF_INET,SOCK_DGRAM)
udp_sever.bind(ip_port)
while True:
data,addr = udp_sever.recvfrom(buffer_size)
if not data:
fmt = "%Y-%m-%d %X"
else:
fmt = data.decode("utf8")
back_time = time.strftime(fmt)
print(back_time)
udp_sever.sendto(back_time.encode("utf8"),addr)
udp客户端1
from socket import *
ip_port = ("127.0.0.1",8080)
buffer_size = 1024
udp_client = socket(AF_INET,SOCK_DGRAM)
while True:
msg = input(">>>").strip()
udp_client.sendto(msg.encode("utf8"),ip_port)
data,addr = udp_client.recvfrom(buffer_size)
print("服务端发回的消息是 ",data.decode("utf8"))