【socket套接字】

socket套接字

socket(简称 套接字) 是进程间通信的一种方式，它与其他进程间通信的一个主要不同是：它能实现不同主机间的进程间通信，我们网络上各种各样的服务大多都是基于 Socket 来完成通信的
例如我们每天浏览网页、QQ 聊天、收发 email 等等

1.socket介绍
1.什么是socket？
socket套接字，是进程通信的一种实现方式
2.主要特点
主要针对不同主机之间的通信。即网络进程的通信，
几乎所有的网络都是通过socket来实现的
3.创建socket的基本流程
1. 创建socket流程,实现网络通信
2. 套接字使用流程 与 文件的使用流程很类似
1. 读写数据到文件的流程
- 打开或者创建文件，取得file对象
file=open()
- 通过file对象读写数据
file.read() file.write()
- 关闭file对象
file.close()
2. 创建socket流程,实现网络通信
1. 创建socket对象
2. 通过socket对象实现发送与接收数据
3. 关闭socket对象
2. socket.socket 创建一个 socket对象，该函数带有两个参数：
Address Family：地址族，可以选择 AF_INET（用于 Internet 进程间通信） 或者 AF_UNIX（用于同一台机器进程间通信）,实际工作中常用AF_INET
Type：套接字类型，可以是 SOCK_DGRAM（数据报套接字，主要用于 UDP 协议）或者 SOCK_STREAM（流式套接字，主要用于 TCP 协议）

socket工作流程

Tcp 服务端：

首先，需要拿到一个 socket 对象，socket 对象 与 ip+port 绑定，才能进行端口的监听;

然后，socket 对象 监听端口是否有请求，同时调用 accept方法，一直阻塞等待客户端的链接；

如果，有客户端的请求发来，那么服务端接受到请求之后，调用 read 方法，读取数据；

之后再处理请求，写回数据使用 write 方法（在 Python 中是 send 方法）

当需要断开链接时，服务端发送请求，客户端读取之后，在调用 close 方法发送断开的请求

服务端 read 收到断开请求，服务端再调用 close 结束链接

Tcp 客户端：

首先，需要拿到一个 socket 对象，调用 connect 方法，传入 IP 与端口，发送建立链接的请求；

之后，就可以进行数据交互，如果需要结束链接，直接调用 close 方法即可。

基于 Tcp 的scoket 服务端与客户端编程

tcp是基于链接的，必须先启动服务端，然后再启动客户端去链接服务端

简易版

服务端

import socket
import time

server = socket.socket()

# 注意传入的参数必须是一个元组或者列表
# ip'127.0.0.1',只能本机自己玩
# 如果写别的 IP 地址可以在局域网中一起玩
server.bind(('127.0.0.1', 8008))

# 监听，半连接池 为 5，相当于队列中最多有 5 个，如果多余 5 个就会报错
# 同时只能服务一个人
server.listen(5)

# 等待客户端的链接
# sock 是连接的对象， addr 是客户端地址
# 以后这个服务端和客户端，使用 sock 这个链接对象
sock, addr = server.accept()

# 接受客户端发了的数据
# 传入的参数为一次接受的字节
data = sock.recv(1024)

print(f'接收到来自{addr}的数据{data.decode("utf-8")}')

# 服务端给客户端发送消息
data_send = f'收到了你发送的 {data}'.encode('utf-8')
# 注意：必须传送二进制的格式
sock.send(data_send)


time.sleep(3)
# 关闭连接对象，此时服务端并没有关闭！！！
sock.close()

# 关闭服务端
server.close()

客户端

import socket

client = socket.socket()

# 连接服务端的地址加端口
client.connect(('127.0.0.1', 8008))

# 连上以后就可以发送消息了
client.send(b'sb')

# 收到服务端返回的消息
data = client.recv(1024)
print(data.decode('utf-8'))

client.close()

加入链接循环

只加入链接循环，此时服务端会一直接收，相当于死循环，服务端不会自动断开

服务端

import socket

server = socket.socket()

server.bind(('127.0.0.1', 8008))

server.listen(5)
print('等待客户端的链接')

# 等待客户端的链接
# 链接循环
while True:
    sock, addr = server.accept()


    # 接受客户端发了的数据
    data = sock.recv(1024)

    print(f'接收到来自{addr}的数据--{data.decode("utf-8")}')


    # 服务端给客户端发送消息
    data_send = f'收到了你发送的 {data}'.encode('utf-8')
    # 注意：必须传送二进制的格式
    sock.send(data_send)


    # 关闭连接对象，此时服务端并没有关闭！！！
    sock.close()

# 关闭服务端
server.close()

客户端

import socket

client = socket.socket()

# 连接服务端的地址加端口
client.connect(('127.0.0.1', 8008))

# 连上以后就可以发送消息了
client.send(b'sb')

# 收到服务端返回的消息
data = client.recv(1024)
print(data.decode('utf-8'))

client.close()

加入通信循环

加入通信循环，此时客户端可以多次发送数据

服务端

import socket

server = socket.socket()
server.bind(('127.0.0.1', 8008))
server.listen(5)
print('等待客户端的链接')

while True:
    sock, addr = server.accept()
    print(f'客户端{addr}已连接')
    # 等待接受客户端发的数据
    # 如果客户端没法，就会一直等待下去
    while True:
        try:
            # 同一个客户端，不停地发送
            data = sock.recv(1024)
            # 当客户端主动断开后，客户端会发送一个空的数据过来
            # 此时服务端必须对这种情况进行处理，否则会出现死循环
            if len(data) == 0:
                print(f'客户端{addr}已断开', '\n')
                break

            print(f'接收到来自{addr}的数据--{data.decode("utf-8")}')
            data_send = f'收到了你发送的 {data}'.encode('utf-8')
            sock.send(data_send)
        except Exception as e:
            print(e)
            break

    sock.close()

# 关闭服务端
server.close()

客户端

import socket

client = socket.socket()
client.connect(('127.0.0.1', 8008))
# 连上以后就可以发送消息了

while True:
    data = input('输入发送给服务端的消息(q to quit)：')
    if data == 'q': break
    client.send(data.encode("utf-8"))

    data = client.recv(1024)
    print(data.decode('utf-8'))

client.close()

支持并发的 Tcp 服务端

在这里是开启多进程完成的并发，可以换成多线程，只需要将 Process 类换成 Thread 类。

import socket
from multiprocessing import Process

def talk(sock,addr):
    print('客户端连接成功', addr)
    while True:
        try:
            data = sock.recv(1024)
            if len(data) == 0:
                print(f'客户端{addr}已断开', '\n')
                break

            print(f'接收到来自{addr}的数据--{data.decode("utf-8")}')
            data_send = f'收到了你发送的 {data}'.encode('utf-8')
            sock.send(data_send)
        except Exception as e:
            print(e)
            break
    sock.close()


if __name__ == '__main__':
    server = socket.socket()
    server.bind(('127.0.0.1', 81))
    server.listen(5)
    while True:
        sock,addr = server.accept()
        print(f'客户端{addr}已连接')
        # 连接上一个客户端之后开启一个进程，对该客户端进行服务
        p = Process(target=talk, args=(sock, addr))
        p.start()

    server.close()

常见问题

1.发送消息不能为空
统计长度并判断即可
2.反复重启服务端可能会报错>>>:address in use
这个错在苹果电脑报的频繁 windows频率较少
from socket import SOL_SOCKET,SO_REUSEADDR
server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) # 在bind前加
3.链接循环
“”"
如果是windows 客户端异常退出之后服务端会直接报错
处理方式
异常处理
如果是mac或linux 服务端会接收到一个空消息
处理方式
len判断
“”"
客户端如果异常断开 服务端代码应该重新回到accept等待新的客人
目前我们的服务端只能实现一次服务一个人 不能做到同事服务多个 学了并发才可以实现

半连接池

listen(5)
# py文件默认同一时间只能运行一次 如果想单独分开运行多次

# 半连接池
	设置的最大等待人数  >>>:  节省资源 提高效率
	

黏包问题

data1 = conn.recv(1024)
print(data1)
data2 = conn.recv(1024)
print(data2)
data3 = conn.recv(1024)
print(data3)

client.send(b'hello')
client.send(b'jason')
client.send(b'kevin')
"""
三次打印的结果
  b'hellojasonkevin'
  b''
  b''
"""

TCP协议的特点

会将数据量比较小并且时间间隔比较短的数据整合到一起发送
并且还会受制于recv括号内的数字大小(核心问题!!!)
流式协议:跟水流一样不间断
“”"
问题产生的原因其实是因为recv括号内我们不知道即将要接收的数据到底多大
如果每次接收的数据我们都能够精确的知道它的大小 那么肯定不会出现黏包
“”"
思路:
困扰我们的核心问题是不知道即将要接收的数据多大
如果能够精准的知道数据量多大 那么黏包问题就自动解决了!!!

解决黏包问题

方向:精准获取数据的大小

  
# struct模块
	import struct

  data1 = 'hello world!'
  print(len(data1))  # 12
  res1 = struct.pack('i', len(data1))  # 第一个参数是格式 写i就可以了
  print(len(res1))  # 4
  ret1 = struct.unpack('i', res1)
  print(ret1)  # (12,)


  data2 = 'hello baby baby baby baby baby baby baby baby'
  print(len(data2))  # 45
  res2 = struct.pack('i', len(data2))
  print(len(res2))  # 4
  ret2 = struct.unpack('i', res2)
  print(ret2)  # (45,)

pack可以将任意长度的数字打包成固定长度
unpack可以将固定长度的数字解包成打包之前数据真实的长度
思路:
1.先将真实数据打包成固定长度的包
2.将固定长度的包先发给对方
3.对方接收到包之后再解包获取真实数据长度
4.接收真实数据长度