套接字（socket）是一个抽象层，应用程序可以通过它发送或接收数据，可对其进行像对文件一样的打开、读写和关闭等操作。
1. 实现客户端发送字符，服务器返回大写的字符：
服务器：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
import socketserver
class MyTCPHandler(socketserver.BaseRequestHandler): # 通过类的继承，实现
def handle(self): # 重写父类的handle方法，所有的操作都在此方法中
while True: # 循环，不停的接收从客户端来的数据
try:
self.data = self.request.recv(1024).strip() # 从客户端接收数据，每次收1024字节
print("{} send:".format(self.client_address), self.data)
self.request.send(self.data.upper()) # 从服务器发送给客户端数据
except ConnectionResetError as e:
print('Error: ',e)
break
if __name__ == '__main__':
host,port = 'localhost',9999
server = socketserver.ThreadingTCPServer((host,port),MyTCPHandler) # 通过多线程实现多个客户端连接，每个客户端连接都是一个线程
server.serve_forever() # 一直运行服务
|
客户端：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
import socket
client = socket.socket() # socket对象
client.connect(('localhost',9999)) # 连接服务器地址和端口
while True: # 循环，不停的输入发送数据
con = input('>>>:').strip()
if len(con) ==0: continue # 不能发送空数据，否则会阻塞
client.send(con.encode('utf-8')) # 发送数据，必须是二进制的
data = client.recv(1024) # 接收服务器返回的数据
print(data.decode()) # 打印 解码后的数据
client.close() # 关闭
|
2. 通过socket执行服务器命令：
用法：直接在客户端输入处输入命令如：ipconfig
服务器：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
import socket
import os
import threading
def tcplink(sock, addr):
print('Accept new connection from %s:%s...' % addr)
while True: # 和每个接入的客户端，进行多次数据通信
data = sock.recv(1024) # 接收客户端数据
if not data or data.decode('utf-8') == 'exit': # 如果客户端不发送数据或者发送了exit
print('client disconnected.')
break
content = os.popen(data.decode('utf-8')).read() # 对发送来的数据执行cmd命令，获取结果
if len(content) == 0: #如果执行的命令结果为空的，就手动造一个结果。因为如果为空数据，会挂起，无法正常发送。
content = 'cmd not exists.'
sock.send(str(len(content.encode('utf-8'))).encode('utf-8')) # 发送数据的长度
print('send length:', (len(content.encode('utf-8'))))
# print('content,', content.encode('utf-8'))
recv = sock.recv(1024) # 因为上下都有一个send连在一起，可能发生粘包现象，为了防止这种情况，可以让客户端重新应答一下
print('Answer:',recv.decode('utf-8'))
sock.send(content.encode('utf-8')) # 发送数据
print('send finished.')
sock.close()
print('Connection from %s:%s closed.' % addr)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 监听端口:
s.bind(('127.0.0.1', 9999))
s.listen(3)
print('Waiting for connection...')
while True:
# 接受一个新连接:
sock, addr = s.accept()
# 创建新线程来处理TCP连接:
t = threading.Thread(target=tcplink, args=(sock, addr))
t.start()
|
客户端：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
import socket
# AF_INET 代表ipv4，SOCK_STREAM 代表TCP
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 确定网络协议，生成对象
s.connect(('127.0.0.1',9999)) # 连接服务器的地址和端口，元组的形式。
while True:
msg = input('>>:').strip()
if len(msg) != 0: # 如果消息为空，会一直挂起，所以不能为空
if msg =='exit':
s.close() # 关闭连接
print('Connection closed.')
break
s.send(msg.encode('utf-8')) # 给服务器发送数据，必须是二进制的
length = s.recv(1024) # 首先接收服务器返回的将要接收的数据的长度信息。
s.send(b'Ready to receive...') # 发送接收命令
length = int(length.decode('utf-8'))
print('receive len:', length)
data_len = 0
data_recv = b''
while data_len < length: # 已经接收的信息的长度，如果小于总长度
data = s.recv(1024) # 从服务器接收数据
data_recv += data
data_len += len(data)
print(data_recv.decode('utf-8')) # 打印返回的数据。
|
3. 通过socket传输文件：
用法：get 文件名
服务器：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
import socket
import os
import hashlib
import threading
def tcplink(sock, addr):
print('Accept new connection from %s:%s...' % addr)
while True: # 和每个接入的客户端，进行多次数据通信
data = sock.recv(1024) # 接收客户端数据
if not data or data.decode('utf-8') == 'exit': # 如果客户端不发送数据或者发送了exit
print('client disconnected.')
break
oper,filename = data.decode('utf-8').split() # 对接收的数据按照空格分割
if oper == 'get':
m = hashlib.md5()
if os.path.isfile(filename):
size = os.stat(filename).st_size # 获取文件大小
print('Send size:',size)
sock.send(str(size).encode('utf-8')) # 发送文件大小
recv = sock.recv(1024) # 接收客户端确认信息(因为上下文两个send是连着的，所以为了防止粘包，接收一次信息)
f = open(filename,'rb')
for line in f:
sock.send(line) #读取文件，发送给客户端
m.update(line)
# print('Send finished.',m.hexdigest()) # 打印md5的值
sock.send(m.hexdigest().encode('utf-8')) # 把md5的值发送给客户端
sock.close()
print('Connection from %s:%s closed.' % addr)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 监听端口:
s.bind(('127.0.0.1', 9999))
s.listen(3)
print('Waiting for connection...')
while True:
# 接受一个新连接:
sock, addr = s.accept()
# 创建新线程来处理TCP连接:
t = threading.Thread(target=tcplink, args=(sock, addr))
t.start()
|
客户端：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
import socket
import hashlib
# AF_INET 代表ipv4，SOCK_STREAM 代表TCP
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 确定网络协议，生成对象
s.connect(('127.0.0.1',9999)) # 连接服务器的地址和端口，元组的形式。
while True:
msg = input('>>:').strip()
if len(msg) != 0: # 如果消息为空，会一直挂起，所以不能为空
if msg =='exit':
s.close() # 关闭连接
print('Connection closed.')
break
s.send(msg.encode('utf-8')) # 给服务器发送数据，必须是二进制的
length = s.recv(1024) # 首先接收服务器返回的将要接收的数据的长度信息。
s.send(b'Ready to receive...') # 发送接收确认命令
length = int(length.decode('utf-8'))
print('Recv size:', length)
data_len = 0
data_recv = b''
# 新文件名
fileName = msg.split()[-1].split('.')[0]
fileExt = msg.split()[-1].split('.')[-1]
newFile = fileName+'-1.'+fileExt
f = open(newFile,'wb') # 打开文件，准备写入服务器发过来的文件
m = hashlib.md5()
while data_len < length: # 已经接收的信息的长度，如果小于总长度
size = length - data_len
if size > 1024: # 如果剩下的信息长度大于1024，即不能一次性发完。
size = 1024
else: # 如果能一次性发完，就只收剩下的信息。目的是准确的接收文件的大小，把可能粘连的send的数据留给下一次recv
size = length-data_len
data = s.recv(size) # 从服务器接收数据
f.write(data)
m.update(data)
data_len += len(data)
f.close()
print('recv_md5:',m.hexdigest()) # 打印返回的数据。
recv = s.recv(1024) # 接收下一次send的数据，即md5的值。
print('orig_md5:',recv.decode())
|
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。
原文链接：https://www.cnblogs.com/wztshine/p/12079510.html