• 第六章 网络编程-SOCKET开发——续1


    6.3——Socket介绍

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

    socket起源于Unix,而Unix/Linux 基本哲学之一就是“一切皆文件”,都可以用“打开open –> 读写write/read –> 关闭close”模式 来操作。Socket就是该模式的一个实现,socket即是一种特殊的文件,一些socket函数就是对其进行的操作(读/写IO、打开、关闭)

    你想给另一台计算机发消息,你知道他的IP地址,他的机器上同时运行着qq、迅雷、word、浏览器等程序,你想给他的qq发消息,那想一下,你现在只能通过ip找到他的机器,但如果让这台机器知道把消息发给qq程序呢?答案就是通过port,一个机器上可以有0-65535个端口,你的程序想从网络上收发数据,就必须绑定一个端口,这样,远程发到这个端口上的数据,就全会转给这个程序啦

    Socket通信套路(10分钟)

    当通过socket建立起2台机器的连接后,本质上socket只干2件事,一是收数据,一是发数据,没数据时就等着。

    socket 建立连接的过程跟我们现实中打电话比较像,打电话必须是打电话方和接电话方共同完成的事情,我们分别看看他们是怎么建立起通话的

    接电话方:

    1.首先你得有个电话
    
    2.你的电话要有号码
    
    3.你的电话必须连上电话线
    
    4.开始在家等电话
    
    5.电话铃响了,接起电话,听到对方的声音

    打电话方:

    1.首先你得有个电话
    
    2.输入你想拨打的电话
    
    3.等待对方接听
    
    4.say “hi 约么,我有七天酒店的打折卡噢~5.等待回应——》响应回应——》等待回应。。。。

    把它翻译成socket通信

    接电话方(socket服务器端):

    1.首先你得有个电话(生成socket对象)
    
    2.你的电话要有号码(绑定本机ip+port)
    
    3.你的电话必须连上电话线(连网)
    
    4.开始在家等电话(开始监听电话listen)
    
    5.电话铃响了,接起电话,听到对方的声音(接受新连接)

    打电话方(socket客户端):

    1.首先你得有个电话(生成socket对象)
    
    2.输入你想拨打的电话(connect 远程主机ip+port)
    
    3.等待对方接听
    
    4.say “hi 约么,我有七天酒店的打折卡噢~”(send() 发消息。。。)
    
    5.等待回应——》响应回应——》等待回应。。。。

    Socket套接字方法

    socket实例类

    socket.socket(family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None)

    family(socket家族)

    • socket.AF_UNIX:用于本机进程间通讯,为了保证程序安全,两个独立的程序(进程)间是不能互相访问彼此的内存的,但为了实现进程间的通讯,可以通过创建一个本地的socket来完成
    • socket.AF_INET:(还有AF_INET6被用于ipv6,还有一些其他的地址家族,不过,他们要么是只用于某个平台,要么就是已经被废弃,或者是很少被使用,或者是根本没有实现,所有地址家族中,AF_INET是使用最广泛的一个,python支持很多种地址家族,但是由于我们只关心网络编程,所以大部分时候我么只使用AF_INET)

    socket type类型

    • socket.SOCK_STREAM #for tcp
    • socket.SOCK_DGRAM #for udp
    • socket.SOCK_RAW #原始套接字,普通的套接字无法处理ICMP、IGMP等网络报文,而SOCK_RAW可以;其次,SOCK_RAW也可以处理特殊的IPv4报文;此外,利用原始套接字,可以通过IP_HDRINCL套接字选项由用户构造IP头。
    • socket.SOCK_RDM #是一种可靠的UDP形式,即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问,在需要执行某些特殊操作时使用,如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。
    • socket.SOCK_SEQPACKET #废弃了

    (Only SOCK_STREAM and SOCK_DGRAM appear to be generally useful.)

    proto=0 请忽略,特殊用途

    fileno=None 请忽略,特殊用途

    服务器套接字函数

    • s.bind() 绑定(主机,端口号)到套接字
    • s.listen() 开始TCP监听
    • s.accept() 被动接受TCP客户的连接,(阻塞式)等待连接的到来

    客户端套接字函数

    • s.connect() 主动初始化TCP服务器连接
    • s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

    公共用途的套系字函数

    • s.recv() 接收数据
    • s.send() 发送数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完,可后面通过实例解释)
    • s.sendall() 发送完整的TCP数据(本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时,数据不丢失,循环调用send直到发完)
    • s.recvfrom() Receive data from the socket. The return value is a pair (bytes, address)
    • s.getpeername() 连接到当前套接字的远端的地址
    • s.close() 关闭套接字
    • socket.setblocking(flag) #True or False,设置socket为非阻塞模式,以后讲io异步时会用
    • socket.getaddrinfo(host, port, family=0, type=0, proto=0, flags=0) 返回远程主机的地址信息,例子 socket.getaddrinfo('luffycity.com',80)
    • socket.getfqdn() 拿到本机的主机名
    • socket.gethostbyname() 通过域名解析ip地址

    6.4——Socket代码实例

    server

    # Echo server program
    import socket
    
    HOST = ''                 # Symbolic name meaning all available interfaces
    PORT = 50007              # Arbitrary non-privileged port
    
    sock_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock_server.bind((HOST, PORT))
    
    sock_server.listen(1) #开始监听,1代表在允许有一个连接排队,更多的新连接连进来时就会被拒绝
    conn, addr = sock_server.accept() #阻塞直到有连接为止,有了一个新连接进来后,就会为这个请求生成一个连接对象
    
    with conn:
        print('Connected by', addr)
        while True:
            data = conn.recv(1024) #接收1024个字节
            if not data: break #收不到数据,就break
            conn.sendall(data) #把收到的数据再全部返回给客户端

    client

    # Echo client program
    import socket
    
    HOST = 'localhost'    # The remote host
    PORT = 50007              # The same port as used by the server
    
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client.connect((HOST, PORT))
    client.sendall(b'Hello, world')
    
    data = client.recv(1024)
    
    print('Received',data)

    循环收发数据

    第一次接触就这么交待了,只说了一句话,感觉不够过瘾,如何实现更多的交互呢?简单,只需要让客户端不断的发,服务端不断的收就可以了,写个循环搞定

    server

    # Echo server program
    import socket
    
    HOST = ''                 # Symbolic name meaning all available interfaces
    PORT = 50007              # Arbitrary non-privileged port
    
    sock_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock_server.bind((HOST, PORT))
    
    sock_server.listen(1) #开始监听,1代表在允许有一个连接排队,更多的新连接连进来时就会被拒绝
    conn, addr = sock_server.accept() #阻塞直到有连接为止,有了一个新连接进来后,就会为这个请求生成一个连接对象
    
    with conn:
        print('Connected by', addr)
        while True:
            data = conn.recv(1024) #接收1024个字节
            print("server recv:",conn.getpeername(), data.decode())
            if not data: break #收不到数据,就break
            conn.sendall(data) #把收到的数据再全部返回给客户端

    client

    # Echo client program
    import socket
    
    HOST = 'localhost'    # The remote host
    PORT = 50007              # The same port as used by the server
    
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client.connect((HOST, PORT))
    
    while True: 
    
        msg = input(">>>:").strip()
        if len(msg) == 0:continue
    
        client.sendall(msg.encode()) #发送用户输入的数据,必须是bytes模式
    
        data = client.recv(1024)
    
        print('Received',data.decode()) #收到服务器的响应后,decode一下

     简单聊天软件

    server

    import socket
    
    HOST = ''                 # Symbolic name meaning all available interfaces
    PORT = 50007              # Arbitrary non-privileged port
    
    sock_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock_server.bind((HOST, PORT))
    
    sock_server.listen(1) #开始监听,1代表在允许有一个连接排队,更多的新连接连进来时就会被拒绝
    conn, addr = sock_server.accept() #阻塞直到有连接为止,有了一个新连接进来后,就会为这个请求生成一个连接对象
    
    with conn:
        print('Connected by', addr)
        while True:
            data = conn.recv(1024) #接收1024个字节
            print("recv from Alex:",conn.getpeername(), data.decode())
            if not data: break #收不到数据,就break
    
            response = input(">>>").strip()
            conn.send(response.encode())
            print("send to alex:",response)

    client不需要做更改,直接 看结果

    冷静的海峰玩了一会这个程序说,Alex你这个有bug,双方只能一来一往的说话,如果你想连续发2句话是不行的,就卡住了。

    对,海峰你说的没错,之所以连续发第2次时会卡住 ,是因为你发了一条消息后,就去调用recv方法接收服务器的响应了,在服务器端返回消息之前,这个recv(1024)方法是阻塞的,如果想允许此时还能再发消息给服务器端,就需要再单独启动一个线程,只负责发消息。当然这就得等我们掌握了线程知识再学啦,此处不多赘述。

    此处补充下listen(1)的演示,就是启动多个客户端连接同一个服务端,发现服务端只能同时处理一个请求

    聊天软件升级版

    刚才在聊天的时候,你会发现,服务端(杠娘)在服务客户端(Alex)的时候,其它人如果也想跟杠娘连接是处于排队状态,然后等Alex完事并断开后,下一个人就跟上,但实际情况是客户端一断开,服务端也跟着断了。

    为什么会断呢?因为服务端以下代码的意思是, 如果收不到数据,就跳出循环,就断开了呀

    conn, addr = sock_server.accept() #阻塞直到有连接为止,有了一个新连接进来后,就会为这个请求生成一个连接对象
    
    with conn:
        print('Connected by', addr)
        while True:
            data = conn.recv(1024) #接收1024个字节
            print("recv from Alex:",conn.getpeername(), data.decode())
    
            if not data: break #收不到数据,就break , 就是它干的
    
            response = input(">>>").strip()
            conn.send(response.encode())
            print("send to alex:",response)

    实现一个客户端断开后,可以立刻接入另外一个客户端的话,怎么办呢?只需再在外层加个循环

    while True: #最外层loop 
    
        conn, addr = sock_server.accept() #阻塞直到有连接为止,有了一个新连接进来后,就会为这个请求生成一个连接对象
        #为何把上面这句话也包含在循环里?
        print("来了个新客人",conn.getpeername() )
    
        with conn:
            print('Connected by', addr)
            while True:
                data = conn.recv(1024) #接收1024个字节
                print("recv from :",conn.getpeername(), data.decode())
                if not data: break #收不到数据,就break
                conn.send(data.upper())
                print("send to alex:",data)

    break跳出后就回到大while那层

    问题:

    有的同学在重启服务端时可能会遇到

    这个是由于你的服务端仍然存在四次挥手的time_wait状态在占用地址(如果不懂,请深入研究1.tcp三次握手,四次挥手 2.syn洪水攻击 3.服务器高并发情况下会有大量的time_wait状态的优化方法)

    解决方法1:

    sock_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock_server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #一行代码搞定,写在bind之前
    sock_server.bind((HOST, PORT))

    解决方法2:

    发现系统存在大量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 时间

    UDP实例

    udp 不需要经过3次握手和4次挥手,不需要提前建立连接,直接发数据就行。

    server端

    import socket
    ip_port=('127.0.0.1',9000)
    BUFSIZE=1024
    udp_server_client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #udp类型
    
    udp_server_client.bind(ip_port)
    
    while True:
        msg,addr=udp_server_client.recvfrom(BUFSIZE)
        print("recv ",msg,addr)
    
        udp_server_client.sendto(msg.upper(),addr)

    client端

    import socket
    ip_port = ('127.0.0.1',9000)
    BUFSIZE = 1024
    udp_server_client = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
    
    while True:
        msg=input('>>: ').strip()
        if not msg:continue
        udp_server_client.sendto(msg.encode('utf-8'),ip_port)
    
        back_msg,addr = udp_server_client.recvfrom(BUFSIZE)
        print(back_msg.decode('utf-8'),addr)

    演示

    TCP VS UDP

    tcp基于链接通信

    • 基于链接,则需要listen(backlog),指定连接池的大小
    • 基于链接,必须先运行的服务端,然后客户端发起链接请求
    • 对于mac系统:如果一端断开了链接,那另外一端的链接也跟着完蛋recv将不会阻塞,收到的是空(解决方法是:服务端在收消息后加上if判断,空消息就break掉通信循环)
    • 对于windows/linux系统:如果一端断开了链接,那另外一端的链接也跟着完蛋recv将不会阻塞,收到的是空(解决方法是:服务端通信循环内加异常处理,捕捉到异常后就break掉通讯循环)

    udp无链接

    • 无链接,因而无需listen(backlog),更加没有什么连接池之说了
    • 无链接,udp的sendinto不用管是否有一个正在运行的服务端,可以己端一个劲的发消息,只不过数据丢失
    • recvfrom收的数据小于sendinto发送的数据时,在mac和linux系统上数据直接丢失,在windows系统上发送的比接收的大直接报错
    • 只有sendinto发送数据没有recvfrom收数据,数据丢失
  • 相关阅读:
    docker6 管理工具
    docker1 初识docker
    libsvm处理多分类的问题
    selenium webdriver 的三种等待方式
    文本深度表示模型Word2Vec
    机器学习中训练集、验证集、测试集的定义和作用
    机器学习中防止过拟合的处理方法
    用Python读取大文件
    进化世界
    EDS(实例)
  • 原文地址:https://www.cnblogs.com/cnlogs1/p/9643678.html
Copyright © 2020-2023  润新知