socket编程

一、TCP、UDP协议的简单应用

1、使用TCP协的通信的基本格式

# 服务端
from socket import *    #导入socket模块

ip_port = ("127.0.0.1",8080)
back_log = 5                #最大连接数（挂起）
buffer_size = 1024          #最大接受字节

tcp_server = socket(AF_INET,SOCK_STREAM)    #注意与UDP的区别
tcp_server.bind(ip_port)        #绑定IP地址
tcp_server.listen(back_log)     #设置最大监听数（挂起）

print("服务端开始运行...")

#循环接受链接（未连接）
while True:
    conn,addr = tcp_server.accept()     #接受数据，为一个元组
    print("双向链接是:",conn)
    print("客户端地址:",addr)

    # 循环接受信息（已连接）
    while True:
        try:            #防止接受的数据为空（None），导致异常
            data = conn.recv(buffer_size)
            if not data:
                break
            print("客户端:
	",data.decode("utf-8"))  #解码
            conn.send(data.upper())
        except Exception:
            break             #退出信息循环层

    conn.close()               #结束与client的连接，等待下一次连接

tcp_server.close()

# 客户端
from socket import *

ip_port = ('127.0.0.1',8080)
back_log = 5
buffer_size = 1024

tcp_client = socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)             #连接服务端

# 循环接受信息
while True:
    msg = input(">>:")
    if not msg:         #发送信息为空时
        continue

    tcp_client.send(msg.encode("utf-8"))
    print("客户端已发送消息")

    data = tcp_client.recv(buffer_size)
    print("客户端已收到消息",data.decode("utf-8"))

tcp_client.close()

注意：

1. 最大连接数指的是，最多可以支持多人挂起，并非同时进行连接
2. 当client断开连接时，会发生异常，需要做异常处理
3. 对于TCP协议，当accept接受到的数据为空时，server端会堵塞

2、使用UDP协的通信的基本格式

# 服务器
from socket import *
ip_port = ("127.0.0.1",8080)
buffer_size = 1024

udp_server = socket(AF_INET,SOCK_DGRAM)
udp_server.bind(ip_port)

print("服务器启动...")

while True:
    data,addr = udp_server.recvfrom(buffer_size)
    print(data.decode("utf-8"))

    udp_server.sendto(data.upper(),addr)

# 客户端
from socket import *

ip_port = ("127.0.0.1",8080)
buffer_size = 1024

udp_client = socket(AF_INET,SOCK_DGRAM)


while True:
    msg = input(">>：")
    if not msg:
        continue
    udp_client.sendto(msg.encode("utf-8"),ip_port)

    data,addr = udp_client.recvfrom(buffer_size)
    print(data.decode("utf-8"))

注意：

1. 使用UDP通信时，并不需要连接，而是在发送数据时，才指定IP地址和端口，所有server接受为空时，并不报错

二、socketserver的使用

利用socketserver达到并发的效果（针对TCP）

import socketserver

class MyServer(socketserver.BaseRequestHandler):    #必须继承这个类
    def handle(self):                           #必须重写这个方法
        print("conn is：",self.request)
        print("addr is：",self.client_address)

        while True:
            try:
                data = self.request.recv(1024)
                print("客户端:
	",data)

                self.request.sendall(data.upper())
            except Exception as e:
                print(e)
                break

if __name__ == '__main__':
    s = socketserver.ThreadingTCPServer(("127.0.0.1",8080),MyServer)
    s.serve_forever()                   #启动

client端不变

注意：

1. 即使，client断开连接，发生异常，server也会继续跟其他client通信
2. 但是，也具有socket的通行，server接受数据为空时，会发生堵塞

三、粘包的发生

1、发送的多条数据远小于缓存区的大小且时间间隔短（为了减少延时，tcp通过算法会把数据合并发送）

from socket import *
import time

ip_port = ("127.0.0.1",8080)
back_log = 5
buffer_size = 1024

tcp_client = socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)

# 第一种粘包
tcp_client.send("Hello".encode("utf-8"))
tcp_client.send("world".encode("utf-8"))
tcp_client.send("lilong".encode("utf-8"))

from socket import *
import time

ip_port = ("127.0.0.1",8080)
back_log = 5
buffer_size = 1024

tcp_client = socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)

# 第一种粘包
tcp_client.send("Hello".encode("utf-8"))

time.sleep(1)

tcp_client.send("world".encode("utf-8"))

time.sleep(1)

tcp_client.send("lilong".encode("utf-8"))

2、发送的数据大于缓存区的大小

from socket import *

ip_port = ("127.0.0.1",8080)
back_log = 5
buffer_size = 1024

tcp_server = socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)

conn,addr = tcp_server.accept()

data1 = conn.recv(5)
print("第1个数据",data1.decode("utf-8"))

data2 = conn.recv(5)
print("第1个数据",data2.decode("utf-8"))

data3 = conn.recv(5)
print("第1个数据",data3.decode("utf-8"))

from socket import *
import time

ip_port = ("127.0.0.1",8080)
back_log = 5
buffer_size = 1024

tcp_client = socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)

tcp_client.send("Helloworld!lilong".encode("utf-8"))

四、粘包的解决方法

1、直接告诉客户端发送数据的字节

server端（核心代码）：

length = len(data)
conn.send(str(length).encode("utf-8"))

client_ready = conn.recv(1024)#卡住
if client_ready == b"ready":           #同步
　　conn.send(data)

client端（核心代码）：

length = tcp_client.recv(buffer_size)
    tcp_client.send(b"ready")

    length = int(length.decode("utf-8"))

    recv_size = 0
    recv_msg = b""
    while recv_size < length:
        recv_msg += tcp_client.recv(buffer_size)
        recv_size = len(recv_msg)

    print("命令的结果是：
	",recv_msg.decode("gbk"))

2、以4个字节为最大发送字节，发送数据

server端（核心代码）：

 length = len(cmd_res)

 data_length = struct.pack('i',length)
 conn.send(data_length)
 conn.send(cmd_res)

client端（核心代码）（bug）：

 length_data = tcp_client.recv(4)
 length = struct.unpack("i",length_data)[0]

 recv_msg = ''.join(iter(partial(tcp_client.recv,1024),b""))

 print("命令的结果是：
	", recv_msg.decode("gbk"))

需要导入两个包

import struct
from functools import partial