Python Day 29 socket、scoket套接字分类、基于TCP的socket、常见错误

  ##什么是socket

“”“
Socket是应用层与TCP/IP协议族通信的中间软件抽象层,它是一组接口。在设计模式中,Socket其实就是一个门面模式,它把复杂的TCP/IP协议族隐藏在Socket接口后面,对用户来说,一组简单的接口就是全部,让Socket去组织数据,以符合指定的协议。

socket在OSI模型中的位置
”“”

  ##为什么需要socket

“”“
在标准的OIS模型中并没有规定说必须有socket层,也就是说不使用socket也能完成通讯,是的,的确如此!

那为什么需要socket呢?一个字 懒,程序员都是懒的!

我们发现还没有开始实现应用程序逻辑,就需要花大把时间来实现各种协议,太特么费事儿了,就有人专门把协议中一堆复杂的事情进行了封装,于是socket就诞生了!

有了socket以后,无需自己编写代码实现三次握手,四次挥手,ARP请求,打包数据等等,socket已经封装好了,只需要遵循socket的规定去编程,写出的程序自然就是遵循tcp/udp标准的。
”“”

  ##scoket套接字分类

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

套接字家族的名字:AF_UNIX

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

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

套接字家族的名字:AF_INET

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

  ##python中的socket

#需明确:关于网络协议 和socket相关概念,对于所有编程语言都是一致的,区别仅仅是各编程语言的函数名称不同

# 1.导入socket模块
import socket
# 2.创建socket对象 函数定义如下
socket.socket(socket_family,socket_type,protocal=0)
    #socket_family 可以是 AF_UNIX 或 AF_INET。
    #socket_type 可以是 SOCK_STREAM表示TCP协议 或 SOCK_DGRAM表示UDP协议。
    #protocol 一般不填,默认值为 0。
    
# 2.1获取TCP 套接字
tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 或者 后面的参数都有默认值,可以不写,默认创建的是TCP协议socket
tcpSock = socket.socket()

# 2.2获取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)


#要明确一点:无论是客户端服务器端都使用的都是socket对象
“”“
服务端套接字函数
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()      得到阻塞套接字操作的超时时间
”“”

  ##基于TCP的socket

#前言:已经明确socket是别人封装好的接口,使用接口就变的简单了

按照通讯流程编写代码即可

  ##TCP通讯流程

   ##socket运行示例

--------------------#socket服务器-------------------------------
import socket

# 作为服务器必明确自己的ip和端口号    并且不应该变化
# 参数1指定 socket类型AF_INET 表示网络类型
#参数2指定的传输协议为 SOCK_STREAM表示TCP协议 SOCK_DGRAM UDP协议
server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)    # 1.买电话机

# 默认就是网络类型   TCP协议
#server = socket.socket()

# 127.0.0.1这叫回送地址   表示当前电脑本身
# ip一定本机ip   本机可能会有多个IP (无线|有限)
# 注意:需要参数是一个元组   端口就是普通整数
server.bind(("127.0.0.1",1688))   # 2.插入手机卡

# 无论是服务器端还是客户端 都是socket 类型

# 开始监听1688端口    盯着这个端口看以后没有数据过来
server.listen()   # 3.手机开始待机

# 接收链接请求
# 第一个是表示客户端的socket    第二个客户端的地址信息
client,addr = server.accept()   # 4.接电话
# print(type(client))
# print(addr)


# 5.收发数据
data = client.recv(1024)
print(data)
client.send("copy!".encode("utf-8"))

server.close()  # 关机

----------------------#socket客户端-----------------------------------
import socket

# 买个电话
client = socket.socket()

# 作为客户端 ip和端口可以变化   所有系统会自动分配随机端给客户端
client.connect(("127.0.0.1",1688))

# 开始通话
# 发送数据   注意发送的内容只能是二进制  bytes
client.send("hello".encode("utf-8"))

# 接收数据  单位为字节
data = client.recv(1024)
print(data)

client.close()

----------------------------------------------------------------------
#总结
注意TCP中必须先启动服务器再启动客户端,否则客户端由于无法链接服务器,直接报错!

   ##改版以后的socket

#注解:一个最基本的TCP通讯,但是建立是为了传输数据,二传输数据很多时候并不是一次性就传输完成了,需要多次收发过程,所以需要给代码加上循环
————————————socket服务器.py————————————————————
import socket
server = socket.socket()
server.bind(("127.0.0.1",8989))
server.listen()

while True:
    client_socket,client_addr = server.accept()
    buffer_size = 1024 #缓冲区  就是一个临时的容器  
    # 缓冲区大小   不能随便写  太大会导致内存溢出    太小效率低    在内存能够承受的情况下 大一些

    while True:
        try:
            data = client_socket.recv(1024)
            # 在linux中 对方如果强行下线了  服务器不会抛出异常 只会收到空消息
            # 得加上判断 如果为空则意味着 对方下线了 应该关闭链接  跳出循环
            # windows上正常关闭 也会收到空消息   if 必须要加
            if not data:
                client_socket.close()
                break

            print(data.decode("utf-8"))  # 解码时必须保证双方同意编码方式
            # 转为大写在发回去
            client_socket.send(data.upper())
        except ConnectionResetError as e:
            print("%s %s" % (client_addr[0],client_addr[1]),e)
            # 如果对方下线了  那服务器也应该关闭对应的客户端对象
            client_socket.close()
            break


# 通常服务器不会关闭
# server.close()
————————————socket客户端.py————————————————————
import socket

client = socket.socket()
# 指定服务器的端口和ip    客户端的端口系统自动分配的
client.connect(("127.0.0.1",8989)) #


# 添加循环 用来重复收发数据
while True:
    # 收发的顺序  必须很对面相反  否则卡死了
    msg = input("输入内容:")
    if not msg:continue
    client.send(msg.encode("utf-8"))
    print("sended!")
    data = client.recv(1024)
    print(data.decode("utf-8"))


client.close()

  ##socket常见错误

#1、端口占用 

在调试过程中,可能会遇见以下错误:
问题发生原因:

1》.可能是由于你已经启动了服务器程序,却又再次启动了服务器程序,同一个端口不能被多个进程使用导致!

2》.三次握手或四次挥手时,发生了异常导致对方程序已经结束而服务器任然处于time_wait状态导致!

3》.在高并发的场景下,由于链接的客户端太多,也会产生大量处于time_wait状态的链接

解决的方案:

​    第1种原因,很简单关闭之前运行的服务器即可

​    第2,3中原因导致的问题,有两种解决方案:

1》.设置服务器重用端口
#加入一条socket配置,重用ip和端口
phone=socket(AF_INET,SOCK_STREAM)
phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它,必须在bind前加
phone.bind(('127.0.0.1',8081))
2》.通过调整linux内核参数解决(了解)
发现系统存在大量TIME_WAIT状态的连接,通过调整linux内核参数解决,
vi /etc/sysctl.conf
编辑文件,加入以下内容:
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_fin_timeout = 30
然后执行 /sbin/sysctl -p 让参数生效。
net.ipv4.tcp_syncookies = 1 表示开启SYN Cookies。当出现SYN等待队列溢出时,启用cookies来处理,可防范少量SYN攻击,默认为0,表示关闭;
net.ipv4.tcp_tw_reuse = 1 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接,默认为0,表示关闭;
net.ipv4.tcp_tw_recycle = 1 表示开启TCP连接中TIME-WAIT sockets的快速回收,默认为0,表示关闭。
net.ipv4.tcp_fin_timeout 修改系統默认的 TIMEOUT 时间

#示例
import socket
server = socket.socket()

server.bind(("127.0.0.1",9891))
server.listen()
server.accept()

server.close()


# 如果已经开启了服务器  再次运行将会抛出 端口占用异常  把之前开启的服务器关掉即可
"""
有些情况   明明已经关闭了进程 但是 还是端口占用  
可能是进程正在后台运行  可以通过端口查出进程  进行关闭
windows下
netstat -ano  | findstr 9898
tasklist | findstr 进程id    拿到进程名称
taskkill /f /t /im 进程名称

大招: 重启电脑
"""

   

2.强行关闭链接
当客服端与服务器链接成功后,如果一方没有执行close,而是直接强行终止程序(或是遇到异常被迫终止),都会导致另一方发送问题,所以要分别在服务端和客户端针对发送和接收代码添加try exception进行异常判断

#错误如下

#示例
---------------------------------socket服务器.py--------------------------------------

import socket

server = socket.socket()

server.bind(("127.0.0.1",8888))  # 只有服务器需要绑定

server.listen()

# accept  是一个阻塞函数  会一直等到有客户端链接过来 在继续执行,没有客户端连进来一直等待
client,addr = server.accept() # 完成了三次握手
# print(client)
# print(addr)

print("握手成功!")
# 收发数据  注意都是用表示客户端的socket来收发数据
# client.send("world".encode("utf-8"))

import time
time.sleep(3)
try:
    # data = client.recv(1024)
    # print("客户端发来的数据:", data)
    # 发送数据时  对方可能也会异常下线 也会抛出异常
    # 接收数据 和发送数据都应该放到try
    client.send("test".encode("utf-8"))

except:
    print("client 下线了")
    # 断开链接
    client.close()  # 完成四次挥手


server.close()
print("服务器关机!")

---------------------------------socket客户端.py--------------------------------------
import socket

client = socket.socket()

# connect本质实在进行三次握手   也是一个数据传输的过程  如果服务器没有立马响应 也会阻塞
#
client.connect(("127.0.0.1",8888))  # 三次握手
print("握手成功! client")


# 发送数据    本质上是把数据交给操作系统来进行发送   一旦数据交给了操作系统 后续的发送
# 应用程序就无法控制了  ,send一般不会卡  当然 如果数据量很大就会阻塞
# client.send("hello".encode("utf-8"))
# print("发送完成")

# 是从操作系统缓存区读取数据   如果当前还没有任何数据 就会进入阻塞
# 会一直等到有数据到来 再继续执行
# try:
#     data = client.recv(1024)
#     print("接收完成!")
#     print(data)
# except:
#     print("服务器 强行下线了!")


import time
time.sleep(10)
# 客户端执行close 是正常关闭链接   会给服务器送空字节  用于表示要断开链接
client.close()
print("关机了!")
原文地址:https://www.cnblogs.com/liangzhenghong/p/10938151.html