基于TCP和UDP的socket

为什么学习socket

　　你自己现在完全可以写一些小程序了，但是前面的学习和练习，我们写的代码都是在自己的电脑上运行的，虽然我们学过了模块引入，文件引入import等等，我可以在程序中获取到另一个文件的内容，对吧，但是那么突然有一天，你的朋友和你说："把你电脑上的一个文件通过你自己写的程序发送到我的电脑上"，这时候怎么办？你是不是会想，what？这怎么搞？就在此时，突然灵感来了，我可以通过qq、云盘、微信等发送给他啊，可是人家说了，让你用自己写的程序啊，嗯，这是个问题，此时又来一个灵感，我给他发送文件肯定是通过网络啊，这就产生了网络，对吧，那我怎么让我的程序能够通过网络来联系到我的朋友呢，并且把文件发送给他呢，那么查了一下，发现网络通信通过socket可以搞，但是怎么搞呢？首先，查询结果是对的，socket就是网络通信的工具，也叫套接字，任何一门语言都有socket，他不是任何一个语言的专有名词，而是大家通过自己的程序与其他电脑进行网络通信的时候都用它。知道为什么要学习socket了吧朋友们而你使用自己的电脑和别人的电脑进行联系并发送消息或者文件等操作就叫做网络通信。

三 C/S架构，B/S架构

客户端英文名称：Client，

浏览器英文名称：Browser.

服务端英文名称：Server，C\S架构就是说的Client\Server架构,B\S架构就是说的Browser\Server架构,。

　　a.硬件C\S架构：打印机。

　　b.软件C\S架构：QQ、微信、优酷、暴风影音、浏览器(IE、火狐，360浏览器等)。

C/S架构优点:个性化设置,响应速度快,

缺点:开发成本高

　　其中浏览器又比较特殊，很多网站是基于浏览器来进行访问的，浏览器和各个网站服务端进行的通讯方式又常被成为B\S架构（B/S架构也是C/S架构的一种）。

B/S架构基于浏览器服务端之间的通信

优点:开发维护成本低,占用空间相对低,用户不固定

缺点:功能单一,没有个性化设置,响应速度相对慢一些

四 osi七层。

详见网络通信原理：https://www.cnblogs.com/jin-xin/articles/10067177.html

五 socket

看socket之前，先来回顾一下五层通讯流程：

但实际上从传输层开始以及以下，都是操作系统帮咱们完成的，下面的各种包头封装的过程，用咱们去一个一个做么？NO！

　　Socket又称为网络套接字，它是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组操作起来非常简单的接口,避免与操作系统的直接对接,省去了繁琐的操作。在python中是一个socket模块,为我们提供了简单的功能

为什么存在socket抽象层?

如果直接与操作系统数据交互非常麻烦,繁琐,socket对这些繁琐的的操作高度的封装,简化.

在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。当我们使用不同的协议进行通信时就得使用不同的接口，还得处理不同协议的各种细节，这就增加了开发的难度，软件也不易于扩展(就像我们开发一套公司管理系统一样，报账、会议预定、请假等功能不需要单独写系统，而是一个系统上多个功能接口，不需要知道每个功能如何去实现的)。于是UNIX BSD就发明了socket这种东西，socket屏蔽了各个协议的通信细节，使得程序员无需关注协议本身，直接使用socket提供的接口来进行互联的不同主机间的进程的通信。这就好比操作系统给我们提供了使用底层硬件功能的系统调用，通过系统调用我们可以方便的使用磁盘（文件操作），使用内存，而无需自己去进行磁盘读写，内存管理。socket其实也是一样的东西，就是提供了tcp/ip协议的抽象，对外提供了一套接口，同过这个接口就可以统一、方便的使用tcp/ip协议的功能了。

　　其实站在你的角度上看，socket就是一个模块。我们通过调用模块中已经实现的方法建立两个进程之间的连接和通信。也有人将socket说成ip+port，因为ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序。所以我们只要确立了ip和port就能找到一个应用程序，并且使用socket模块来与之通信。

五套接字发展史及分类

套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。

基于文件类型的套接字家族

套接字家族的名字：AF_UNIX

unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信

基于网络类型的套接字家族

套接字家族的名字：AF_INET

(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)

六套接字的工作流程（基于TCP和 UDP两个协议）

6.1 TCP和UDP对比

TCP（Transmission Control Protocol）可靠的、面向连接的协议（eg:打电话）、传输效率低全双工通信（发送缓存&接收缓存）、面向字节流。使用TCP的应用：Web浏览器；文件传输程序。

UDP（User Datagram Protocol）不可靠的、无连接的服务，传输效率高（发送前时延小），一对一、一对多、多对一、多对多、面向报文(数据包)，尽最大努力服务，无拥塞控制。使用UDP的应用：域名系统 (DNS)；视频流；IP语音(VoIP)。

6.2 TCP协议下的socket

个生活中的场景。你要打电话给一个朋友，先拨号，朋友听到电话铃声后提起电话，这时你和你的朋友就建立起了连接，就可以讲话了。等交流结束，挂断电话结束此次交谈。生活中的场景就解释了这工作原理。

　　先从服务器端说起。服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束

细说socket()模块函数用法

import socket

socket.socket(socket_family,socket_type,protocal=0)

 socket_family 可以是 AF_UNIX 或 AF_INET。socket_type 可以是 SOCK_STREAM 或 SOCK_DGRAM。protocol 一般不填,默认值为 0。

 获取tcp/ip套接字

tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

获取udp/ip套接字

udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

由于 socket 模块中有太多的属性。我们在这里破例使用了'from module import *'语句。使用 'from socket import *',我们就把 socket 模块里的所有属性都带到我们的命名空间里了,这样能 大幅减短我们的代码。

例如tcpSock = socket(AF_INET, SOCK_STREAM)

服务端套接字函数

s.bind()    绑定(主机,端口号)到套接字

s.listen()  开始TCP监听

s.accept()  被动接受TCP客户的连接,(阻塞式)等待连接的到来

客户端套接字函数

s.connect()     主动初始化TCP服务器连接

s.connect_ex()  connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

公共用途的套接字函数

s.recv()            接收TCP数据

s.send()            发送TCP数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完)

s.sendall()         发送完整的TCP数据(本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时,数据不丢失,循环调用send直到发完)

s.recvfrom()        接收UDP数据

s.sendto()          发送UDP数据

s.getpeername()     连接到当前套接字的远端的地址

s.getsockname()     当前套接字的地址

s.getsockopt()      返回指定套接字的参数

s.setsockopt()      设置指定套接字的参数

s.close()           关闭套接字

面向锁的套接字方法

s.setblocking()     设置套接字的阻塞与非阻塞模式

s.settimeout()      设置阻塞套接字操作的超时时间

s.gettimeout()      得到阻塞套接字操作的超时时间

面向文件的套接字的函数

s.fileno()          套接字的文件描述符

s.makefile()        创建一个与该套接字相关的文件

第一版，单个客户端与服务端通信（low版）

# 网络通信与打电话（诺基亚）是一样的。

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)  # 买电话

phone.bind(('127.0.0.1',8080))  # 0 ~ 65535  1024之前系统分配好的端口 绑定电话卡

phone.listen(5)  # 同一时刻有5个请求，但是可以有N多个链接。 开机。

conn, client_addr = phone.accept()  # 接电话

print(conn, client_addr, sep='\n')

from_client_data = conn.recv(1024)  # 一次接收的最大限制  bytes

print(from_client_data.decode('utf-8'))

conn.send(from_client_data.upper())

conn.close()  # 挂电话

phone.close() # 关机

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)  # 买电话

phone.connect(('127.0.0.1',8080))  # 与客户端建立连接， 拨号

phone.send('hello'.encode('utf-8'))

from_server_data = phone.recv(1024)

print(from_server_data)

phone.close()  # 挂电话

第二版，通信循环

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.bind(('127.0.0.1',8080))

phone.listen(5)

conn, client_addr = phone.accept()

print(conn, client_addr, sep='\n')

while 1:  # 循环收发消息

    try:

        from_client_data = conn.recv(1024)

        print(from_client_data.decode('utf-8'))

        conn.send(from_client_data + b'SB')

    except ConnectionResetError:

        break

conn.close()

phone.close()

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)  # 买电话

phone.connect(('127.0.0.1',8080))  # 与客户端建立连接， 拨号

while 1:  # 循环收发消息

    client_data = input('>>>')

    phone.send(client_data.encode('utf-8'))

    from_server_data = phone.recv(1024)

    print(from_server_data.decode('utf-8'))

phone.close()  # 挂电话

第三版，通信，连接循环

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.bind(('127.0.0.1',8080))

phone.listen(5)

while 1 : # 循环连接客户端

    conn, client_addr = phone.accept()

    print(client_addr)

    while 1:

        try:

            from_client_data = conn.recv(1024)

            print(from_client_data.decode('utf-8'))

            conn.send(from_client_data + b'SB')

        except ConnectionResetError:

            break

conn.close()

phone.close()

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)  # 买电话

phone.connect(('127.0.0.1',8080))  # 与客户端建立连接， 拨号

while 1:

    client_data = input('>>>')

    phone.send(client_data.encode('utf-8'))

    from_server_data = phone.recv(1024)

    print(from_server_data.decode('utf-8'))

phone.close()  # 挂电话

详解recv的工作原理

当缓冲区没有数据可取时，recv会一直处于阻塞状态，直到缓冲区至少有一个字节数据可取，或者远程端关闭。

关闭远程端并读取所有数据后，返回空字符串。

'''

源码解释：

Receive up to buffersize bytes from the socket.

接收来自socket缓冲区的字节数据，

For the optional flags argument, see the Unix manual.

对于这些设置的参数，可以查看Unix手册。

When no data is available, block untilat least one byte is available or until the remote end is closed.

当缓冲区没有数据可取时，recv会一直处于阻塞状态，直到缓冲区至少有一个字节数据可取，或者远程端关闭。

When the remote end is closed and all data is read, return the empty string.

关闭远程端并读取所有数据后，返回空字符串。

'''

----------服务端------------：

# 1，验证服务端缓冲区数据没有取完，又执行了recv执行，recv会继续取值。

import socket

phone =socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.bind(('127.0.0.1',8080))

phone.listen(5)

conn, client_addr = phone.accept()

from_client_data1 = conn.recv(2)

print(from_client_data1)

from_client_data2 = conn.recv(2)

print(from_client_data2)

from_client_data3 = conn.recv(1)

print(from_client_data3)

conn.close()

phone.close()

# 2，验证服务端缓冲区取完了，又执行了recv执行，此时客户端20秒内不关闭的前提下，recv处于阻塞状态。

import socket

phone =socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.bind(('127.0.0.1',8080))

phone.listen(5)

conn, client_addr = phone.accept()

from_client_data = conn.recv(1024)

print(from_client_data)

print(111)

conn.recv(1024) # 此时程序阻塞20秒左右，因为缓冲区的数据取完了，并且20秒内，客户端没有关闭。

print(222)

conn.close()

phone.close()

# 3 验证服务端缓冲区取完了，又执行了recv执行，此时客户端处于关闭状态，则recv会取到空字符串。

import socket

phone =socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.bind(('127.0.0.1',8080))

phone.listen(5)

conn, client_addr = phone.accept()

from_client_data1 = conn.recv(1024)

print(from_client_data1)

from_client_data2 = conn.recv(1024)

print(from_client_data2)

from_client_data3 = conn.recv(1024)

print(from_client_data3)

conn.close()

phone.close()

------------客户端------------

# 1，验证服务端缓冲区数据没有取完，又执行了recv执行，recv会继续取值。

import socket

import time

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.connect(('127.0.0.1',8080))

phone.send('hello'.encode('utf-8'))

phone.close()

# 2，验证服务端缓冲区取完了，又执行了recv执行，此时客户端20秒内不关闭的前提下，recv处于阻塞状态。

import socket

import time

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.connect(('127.0.0.1',8080))

phone.send('hello'.encode('utf-8'))

phone.close()

# 3，验证服务端缓冲区取完了，又执行了recv执行，此时客户端处于关闭状态，则recv会取到空字符串。

import socket

import time

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.connect(('127.0.0.1',8080))

phone.send('hello'.encode('utf-8'))

phone.close()

远程执行命令的示例：

import socket

import subprocess

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.bind(('127.0.0.1',8080))

phone.listen(5)

while 1 : # 循环连接客户端

    conn, client_addr = phone.accept()

    print(client_addr)

    while 1:

        try:

            cmd = conn.recv(1024)

            ret = subprocess.Popen(cmd.decode('utf-8'),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)

            correct_msg = ret.stdout.read()

            error_msg = ret.stderr.read()

            conn.send(correct_msg + error_msg)

        except ConnectionResetError:

            break

conn.close()

phone.close()

# shell: 命令解释器，相当于调用cmd 执行指定的命令。

# stdout:正确结果丢到管道中。

# stderr:错了丢到另一个管道中。

# windows操作系统的默认编码是gbk编码。

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)  # 买电话

phone.connect(('127.0.0.1',8080))  # 与客户端建立连接， 拨号

while 1:

    cmd = input('>>>')

    phone.send(cmd.encode('utf-8'))

    from_server_data = phone.recv(1024)

    print(from_server_data.decode('gbk'))

phone.close()  # 挂电话

6.3 UDP协议下的socket

udp是无链接的，先启动哪一端都不会报错

UDP下的socket通讯流程

　　先从服务器端说起。服务器端先初始化Socket，然后与端口绑定(bind)，recvform接收消息，这个消息有两项，消息内容和对方客户端的地址，然后回复消息时也要带着你收到的这个客户端的地址，发送回去，最后关闭连接，一次交互结束

上代码感受一下，需要创建两个文件，文件名称随便起，为了方便看，我的两个文件名称为udp_server.py(服务端)和udp_client.py(客户端)，将下面的server端的代码拷贝到udp_server.py文件中，将下面cliet端的代码拷贝到udp_client.py的文件中，然后先运行udp_server.py文件中的代码，再运行udp_client.py文件中的代码，然后在pycharm下面的输出窗口看一下效果。

sever端代码示例

# 1. 基于udp协议的socket无须建立管道,先开启服务端或者客户端都行.

# 2. 基于udp协议的socket接收一个消息,与发送一个消息都是无连接的.

# 3. 只要拿到我的ip地址和端口就都可以给我发消息,我按照顺序接收消息.

import socket

udp_sk = socket.socket(type=socket.SOCK_DGRAM)   #创建一个服务器的套接字

udp_sk.bind(('127.0.0.1',9000))        #绑定服务器套接字

msg,addr = udp_sk.recvfrom(1024)

print(msg)

udp_sk.sendto(b'hi',addr)                 # 对话(接收与发送)

udp_sk.close()                         # 关闭服务器套接字

client端代码示例

import socket

ip_port=('127.0.0.1',9000)

udp_sk=socket.socket(type=socket.SOCK_DGRAM)

udp_sk.sendto(b'hello',ip_port)

back_msg,addr=udp_sk.recvfrom(1024)

print(back_msg.decode('utf-8'),addr)

类似于qq聊天的代码示例：

#_*_coding:utf-8_*_

import socket

ip_port=('127.0.0.1',8081)

udp_server_sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #DGRAM:datagram 数据报文的意思，象征着UDP协议的通信方式

udp_server_sock.bind(ip_port)#你对外提供服务的端口就是这一个，所有的客户端都是通过这个端口和你进行通信的

while True:

    qq_msg,addr=udp_server_sock.recvfrom(1024)# 阻塞状态，等待接收消息

    print('来自[%s:%s]的一条消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],qq_msg.decode('utf-8')))

    back_msg=input('回复消息: ').strip()

    udp_server_sock.sendto(back_msg.encode('utf-8'),addr)

import socket

BUFSIZE=1024

udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

qq_name_dic={

    'taibai':('127.0.0.1',8081),

    'Jedan':('127.0.0.1',8081),

    'Jack':('127.0.0.1',8081),

    'John':('127.0.0.1',8081),

}

while True:

    qq_name=input('请选择聊天对象: ').strip()

    while True:

        msg=input('请输入消息,回车发送,输入q结束和他的聊天: ').strip()

        if msg == 'q':break

        if not msg or not qq_name or qq_name not in qq_name_dic:continue

        udp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name])# 必须带着自己的地址，这就是UDP不一样的地方，不需要建立连接，但是要带着自己的地址给服务端，否则服务端无法判断是谁给我发的消息，并且不知道该把消息回复到什么地方，因为我们之间没有建立连接通道

        back_msg,addr=udp_client_socket.recvfrom(BUFSIZE)# 同样也是阻塞状态，等待接收消息

        print('来自[%s:%s]的一条消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],back_msg.decode('utf-8')))

udp_client_socket.close()

　　接下来，给大家说一个真实的例子，也就是实际当中应用的，那么这是个什么例子呢？就是我们电脑系统上的时间，windows系统的时间是和微软的时间服务器上的时间同步的，而mac本是和苹果服务商的时间服务器同步的，这是怎么做的呢，首先他们的时间服务器上的时间是和国家同步的，你们用我的系统，那么你们的时间只要和我时间服务器上的时间同步就行了，对吧，我时间服务器是不是提供服务的啊，相当于一个服务端，我们的电脑就相当于客户端，就是通过UDP来搞的。

自制时间服务器的代码示例：

from socket import *

from time import strftime

import time

ip_port = ('127.0.0.1', 9000)

bufsize = 1024

tcp_server = socket(AF_INET, SOCK_DGRAM)

tcp_server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)

tcp_server.bind(ip_port)

while True:

    msg, addr = tcp_server.recvfrom(bufsize)

    print('===>', msg)

    stru_time = time.localtime()  #当前的结构化时间

    if not msg:

        time_fmt = '%Y-%m-%d %X'

    else:

        time_fmt = msg.decode('utf-8')

    back_msg = strftime(time_fmt,stru_time)

    print(back_msg,type(back_msg))

    tcp_server.sendto(back_msg.encode('utf-8'), addr)

tcp_server.close()

from socket import *

ip_port=('127.0.0.1',9000)

bufsize=1024

tcp_client=socket(AF_INET,SOCK_DGRAM)

while True:

    msg=input('请输入时间格式(例%Y %m %d)>>: ').strip()

    tcp_client.sendto(msg.encode('utf-8'),ip_port)

    data=tcp_client.recv(bufsize)

    print('当前日期：',str(data,encoding='utf-8'))

七粘包

讲粘包之前先看看socket缓冲区的问题：

为什么存在缓冲区?

暂时存储一些数据
避免网络有波动是造成数据数据收发卡顿

缺点:造成了粘包现象之一

粘包现象的情况:

连续短暂的send多次(数据量小),数据会统一发送
send的数据过大，大于对方recv的上限时，对方第二次recv时，会接收上一次没有recv完的剩余的数据。

[](javascript:void(0)

巴特西

基于TCP和UDP的socket

为什么学习socket

三 C/S架构，B/S架构

四 osi七层。

五 socket

五套接字发展史及分类

六套接字的工作流程（基于TCP和 UDP两个协议）

6.1 TCP和UDP对比

6.2 TCP协议下的socket

6.3 UDP协议下的socket

七粘包

最新文章

热门文章

巴特西

基于TCP和UDP的socket

为什么学习socket

三 C/S架构，B/S架构

四 osi七层。

五 socket

五 套接字发展史及分类

六 套接字的工作流程（基于TCP和 UDP两个协议）

6.1 TCP和UDP对比

6.2 TCP协议下的socket

6.3 UDP协议下的socket

七 粘包

最新文章

热门文章

五套接字发展史及分类

六套接字的工作流程（基于TCP和 UDP两个协议）

七粘包