zoukankan      html  css  js  c++  java
  • 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("关机了!")
  • 相关阅读:
    python 安装impala包
    Hive表导出成csv文件
    linux sed命令详解
    Android--Sensor传感器
    Android--ColorMatrix改变图片颜色
    Android--Matrix图片变换处理
    Android--使用Canvas绘图
    Android--从系统Camera和Gallery获取图片优化
    Android--从系统Gallery获取图片
    Android--Tween补间动画
  • 原文地址:https://www.cnblogs.com/liangzhenghong/p/10938151.html
Copyright © 2011-2022 走看看