# === TCP 服务端程序 server.py ===
# 导入socket 库
from socket import *
# 主机地址为空字符串，表示绑定本机所有网络接口ip地址
# 等待客户端来连接
IP = ''
# 端口号
PORT = 50000
# 定义一次从socket缓冲区最多读入512个字节数据
BUFLEN = 512
# 实例化一个socket对象
# 参数 AF_INET 表示该socket网络层使用IP协议
# 参数 SOCK_STREAM 表示该socket传输层使用TCP协议
listenSocket = socket(AF_INET, SOCK_STREAM)
# socket绑定地址和端口
listenSocket.bind((IP, PORT))
# 使socket处于监听状态，等待客户端的连接请求
# 参数 8 表示 最多接受多少个等待连接的客户端
listenSocket.listen(8)
print(f'服务端启动成功，在{PORT}端口等待客户端连接...')
dataSocket, addr = listenSocket.accept()
print('接受一个客户端连接:', addr)
while True:
# 尝试读取对方发送的消息
# BUFLEN 指定从接收缓冲里最多读取多少字节
recved = dataSocket.recv(BUFLEN)
# 如果返回空bytes，表示对方关闭了连接
# 退出循环，结束消息收发
if not recved:
break
# 读取的字节数据是bytes类型，需要解码为字符串
info = recved.decode()
print(f'收到对方信息： {info}')
# 发送的数据类型必须是bytes，所以要编码
dataSocket.send(f'服务端接收到了信息 {info}'.encode())
# 服务端也调用close()关闭socket
dataSocket.close()
listenSocket.close()
# === TCP 客户端程序 client.py ===
from socket import *
IP = '127.0.0.1'
SERVER_PORT = 50000
BUFLEN = 1024
# 实例化一个socket对象，指明协议
dataSocket = socket(AF_INET, SOCK_STREAM)
# 连接服务端socket
dataSocket.connect((IP, SERVER_PORT))
while True:
# 从终端读入用户输入的字符串
toSend = input('>>> ')
if toSend =='exit':
break
# 发送消息，也要编码为 bytes
dataSocket.send(toSend.encode())
# 等待接收服务端的消息
recved = dataSocket.recv(BUFLEN)
# 如果返回空bytes，表示对方关闭了连接
if not recved:
break
# 打印读取的信息
print(recved.decode())
dataSocket.close()
# === TCP 服务端程序 server.py ， 支持多客户端 ===
# 导入socket 库
from socket import *
from threading import Thread
IP = ''
PORT = 50000
BUFLEN = 512
# 这是新线程执行的函数，每个线程负责和一个客户端进行通信
def clientHandler(dataSocket,addr):
while True:
recved = dataSocket.recv(BUFLEN)
# 当对方关闭连接的时候，返回空字符串
if not recved:
print(f'客户端{addr} 关闭了连接' )
break
# 读取的字节数据是bytes类型，需要解码为字符串
info = recved.decode()
print(f'收到{addr}信息： {info}')
dataSocket.send(f'服务端接收到了信息 {info}'.encode())
dataSocket.close()
# 实例化一个socket对象 用来监听客户端连接请求
listenSocket = socket(AF_INET, SOCK_STREAM)
# socket绑定地址和端口
listenSocket.bind((IP, PORT))
listenSocket.listen(8)
print(f'服务端启动成功，在{PORT}端口等待客户端连接...')
while True:
# 在循环中，一直接受新的连接请求
dataSocket, addr = listenSocket.accept() # Establish connection with client.
addr = str(addr)
print(f'一个客户端 {addr} 连接成功' )
# 创建新线程处理和这个客户端的消息收发
th = Thread(target=clientHandler,args=(dataSocket,addr))
th.start()
listenSocket.close()
# 方式2，使用asyncio 库
# === TCP 服务端程序 server.py 异步支持多客户端 ===
import asyncio, socket
IP = ''
PORT = 50000
BUFLEN = 512
# 定义处理数据收发的回调
async def handle_echo(reader, writer):
addr = writer.get_extra_info('peername')
while True:
data = await reader.read(100)
if not data:
print(f'客户端{addr}关闭了连接')
writer.close()
break
message = data.decode()
print(f'收到{addr}信息： {message}')
writer.write(data)
loop = asyncio.get_event_loop()
coro = asyncio.start_server(handle_echo, IP, PORT, loop=loop)
server = loop.run_until_complete(coro)
# Serve requests until Ctrl+C is pressed
print('服务端启动成功，在{}端口等待客户端连接...'.format(server.sockets[0].getsockname()[1]))
try:
loop.run_forever()
except KeyboardInterrupt:
pass
# Close the server
server.close()
loop.run_until_complete(server.wait_closed())
loop.close()
# === UDP 服务端程序 ===
import socket,json
BUFF_LEN = 400 # 最大报文长度
ADDR = ("", 18000) # 指明服务端地址，IP地址为空表示本机所有IP
# 创建 UDP Socket
server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 绑定地址
server_socket.bind(ADDR)
while True:
try:
recvbytes, client_addr = server_socket.recvfrom(BUFF_LEN)
except socket.timeout:
continue
print(f'来自 {client_addr} 的请求')
# 接收到的信息是字节，所以要解码，再反序列化
message = json.loads(recvbytes.decode('utf8'))
print(message)
if message['action'] == '获取信息':
# 可以从数据库的数据源查询 此用户的信息
username = message['name']
# 要发送的信息 对象
message = {
'action' : '返回信息',
'info' : f'{username} 的信息是:xxxxxxxx'
}
# 发送出去的信息必须是字节，所以要先序列化，再编码
sendbytes = json.dumps(message).encode('utf8')
server_socket.sendto(sendbytes, client_addr)
# === UDP 客户端程序 ===
import socket,json
BUFF_LEN = 400 # 最大报文长度
SERVER_ADDR = ("127.0.0.1", 18000) # 指明服务端地址
# 创建 UDP Socket
client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 设置socket超时时间，单位：秒
client_socket.settimeout(2)
# 要发送的信息 对象
message = {
'action' : '获取信息',
'name' : '白月黑羽'
}
# 发送出去的信息必须是字节，所以要先序列化，再编码
sendbytes = json.dumps(message).encode('utf8')
client_socket.sendto(sendbytes, SERVER_ADDR)
try:
recvbytes, server = client_socket.recvfrom(BUFF_LEN)
# 接收到的信息是字节，所以要解码，再反序列化
message = json.loads(recvbytes.decode('utf8'))
print(message)
except socket.timeout:
print('接收消息超时')
