今日内容概要

• Socket抽象层(socket编程)

• 基于TCP协议的借助socket可以编程客户端和服务端的程序

  • 链接循环

  • 通信循环

• 基于UDP协议的套接字(socket)编程

• 粘包现象

• 如何解决粘包现象(重要的是解决的思路)

• struct模块的使用(打包、解包)

今日内容详细

Socket抽象层（socke编程）

我们知道两个进程如果需要进行通讯最基本的一个前提是能够唯一标示一个进程，在本地进程通讯中我们可以使用PID来唯一标示一个进程，但PID只在本地唯一，网络中的两个进程PID冲突几率很大，这时候我们需要另辟蹊径，我们知道IP层的IP地址可以唯一标示主机，而TCP层协议和端口号可以唯一标示主机的一个进程，这样我们可以利用IP地址+协议+端口号可以唯一标示主机的一个进程。

能够唯一标示网络中的进程后，它们就可以利用Socket进行通信了，什么是Socket呢？我们经常把Socket翻译为套接字，Socket是在应用层和传输层之间的一个抽象层，它把TCP/IP层复杂的操作抽象为几个简单的接口供应用层调用已实现进程在网络中通信

Socket起源于UNIX，在Unix一切皆文件哲学下的思想下，Socket是一种“打——读/写——关闭”魔模式的实现，在服务器和客户端各自维护一个“文件”，在建立链接打开后，可以向自己文件写入内容供对方读取或者读取对方内容，通讯结束时关闭文件。

基于文件类型的套接字家族：
    # 套接字家族的名字：AF_UNIX

基于网络类型的套接字家族
    # 套接字家族的名字：AF_INET

基于TCP协议的套接字(socket)编程

客户端和服务端应该是谁先发送消息：
客户端先发送消息，需要服务端先运行起来

“服务端代码”

import socket
from socket import AF_INET
# socket.socket() # AF_INET, type=SOCK_STREAM: 基于TCP协议的
server=socket.socket(family=AF_INET, type=socket.SOCK_STREAM) # AF_INET, type=SOCK_DGRAM: 基于UDP协议的

# 绑定IP地址和port
server.bind(('127.0.0.1', 8000))

# 服务端做监听，也称为是半链接池(服务端能够同时等待客户端的数量)
server.listen(3)
print(123)
# 该接收客户端发来的消息
sock, addr = server.accept() #  """我们知道代码运行到这里，就会卡主，等待客户端开发链接和发送消息"""
"""sock:当前链接的客户端的链接， addr:就是客户端的地址：ip，port"""
print(234)
# 想拿到客户端实际发过来的数据
data=sock.recv(1024) # 接收的数据类型是bytes类型，二进制的 1024 代表接收的最多的字节数
print("接收客户端的数据：",data)
# 要给客户端返回一个数据
sock.send(data.upper()) # 发送的数据是字节类型的

# 关闭链接
sock.close()

server.close()

“客户端代码”

import socket
from socket import AF_INET
client=socket.socket(family=AF_INET, type=socket.SOCK_STREAM)
# socket.socket()

client.connect(('127.0.0.1', 8000))

# 开始给服务端发送消息
client.send('hello'.encode('utf-8'))

# 接收服务端发来的消息
data=client.recv(1024)
print("服务端发来的消息：", data)
client.close()

加上通信和通信循环

import socket
from socket import AF_INET
# socket.socket() # AF_INET, type=SOCK_STREAM: 基于TCP协议的
server=socket.socket(family=AF_INET, type=socket.SOCK_STREAM) # AF_INET, type=SOCK_DGRAM: 基于UDP协议的

# 绑定IP地址和port
server.bind(('127.0.0.1', 8000))

# 服务端做监听，也称为是半链接池(服务端能够同时等待客户端的数量)
server.listen(3)

while True:
    # 该接收客户端发来的消息
    sock, addr = server.accept() #  """我们知道代码运行到这里，就会卡主，等待客户端开发链接和发送消息"""
    """sock:当前链接的客户端的链接， addr:就是客户端的地址：ip，port"""

    while True:
        # 想拿到客户端实际发过来的数据
        try:
            """客户端发送过来的数据是个空，或者"""
            data=sock.recv(1024) # 接收的数据类型是bytes类型，二进制的 1024 代表接收的最多的字节数
            print("接收客户端的数据：",data)
            # 要给客户端返回一个数据
            sock.send(data.upper()) # 发送的数据是字节类型的
        except Exception as e:
            print(e)
            break
    # 关闭链接
    sock.close()

server.close()

###########################客户端####################################
import socket
from socket import AF_INET
client=socket.socket(family=AF_INET, type=socket.SOCK_STREAM)
# socket.socket()

client.connect(('127.0.0.1', 8000))

while True:
    send_data = input('请输入你要发送给服务端的数据:')

    # 开始给服务端发送消息
    client.send(send_data.encode('utf-8'))

    # 接收服务端发来的消息
    data=client.recv(1024)
    print("服务端发来的消息：", data)
client.close()

基于UDP协议的套接字编程

“客户端”

import socket

client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  # 数据报协议-》UDP

while True:
    msg = input('>>: ').strip()  # msg=''
    client.sendto(msg.encode('utf-8'), ('127.0.0.1', 8080))
    data, server_addr = client.recvfrom(1024)
    print(data)

client.close()


"""服务端"""
import socket

server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  # 数据报协议-》UDP
server.bind(('127.0.0.1', 8080))

while True:
    """client_addr: 客户端的地址"""
    data, client_addr = server.recvfrom(1024) # 接收的最大字节数
    print('===>', data, client_addr)
    server.sendto(data.upper(), client_addr)

server.close()

粘包现象

注意：只有TCP有粘包现象，UDP永远不会粘包

粘包的两种情况

1.发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包
服务端

Copy# _*_coding:utf-8_*_
__author__ = 'lqz'
from socket import *
ip_port = ('127.0.0.1', 8080)

TCP_socket_server = socket(AF_INET, SOCK_STREAM)
TCP_socket_server.bind(ip_port)
TCP_socket_server.listen(5)

conn, addr = TCP_socket_server.accept()

data1 = conn.recv(10)
data2 = conn.recv(10)

print('----->', data1.decode('utf-8'))
print('----->', data2.decode('utf-8'))

conn.close()

客户端

Copy# _*_coding:utf-8_*_
__author__ = 'lqz'
import socket
BUFSIZE = 1024
ip_port = ('127.0.0.1', 8080)

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
res = s.connect_ex(ip_port)

s.send('hello'.encode('utf-8'))
s.send('feng'.encode('utf-8'))

2.接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）

服务端

Copy# _*_coding:utf-8_*_
__author__ = 'lqz'
from socket import *
ip_port = ('127.0.0.1', 8080)

TCP_socket_server = socket(AF_INET, SOCK_STREAM)
TCP_socket_server.bind(ip_port)
TCP_socket_server.listen(5)

conn, addr = TCP_socket_server.accept()

data1 = conn.recv(2)  # 一次没有收完整
data2 = conn.recv(10)  # 下次收的时候,会先取旧的数据,然后取新的

print('----->', data1.decode('utf-8'))
print('----->', data2.decode('utf-8'))

conn.close()

客户端

Copy# _*_coding:utf-8_*_
__author__ = 'lqz'
import socket
BUFSIZE = 1024
ip_port = ('127.0.0.1', 8080)

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
res = s.connect_ex(ip_port)

s.send('hello feng'.encode('utf-8'))