Python基础第24天

第五模块：网络编程    

一：C/S架构

即C/S架构，包括

1.硬件C/S架构(打印机)

2.软件C/S架构(web服务)

二：socket和互联网协议

1.首先：本节课程的目标就是教会你如何基于socket编程，来开发一款自己的C/S架构软件

2.其次：C/S架构的软件（软件属于应用层）是基于网络进行通信的

3.然后：网络的核心即一堆协议，协议即标准，你想开发一款基于网络通信的软件，就必须遵循这些标准。

TCP/IP协议族包括运输层、网络层、链路层

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让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()           关闭套接字三：例子1：基于tcp套接字

from socket import *
ip_port=(‘127.0.0.1‘,8086)
back_log=5
buffer_size=1024

tcp_server=socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)
print(‘服务端开始运作‘)
while True:   #接收多个人的链接
    conn,addr=tcp_server.accept()
    print(‘双向连接是‘,conn)
    print(‘客户端地址‘,addr)

    while True:  #跟一个人循环连接
        try:
            data=conn.recv(buffer_size)
            print(‘客户端发来的消息是‘,data.decode(‘utf_8‘))
            conn.send(data.upper())
        except Exception:
            break
    conn.close()
tcp_server.close()

server

from socket import *
ip_port=(‘127.0.0.1‘,8086)
back_log=5
buffer_size=1024

tcp_client=socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)

while True:
    msg=input(‘》》》:‘).strip()
    tcp_client.send(‘hello‘.encode(‘utf-8‘))
    print(‘客户端已经发送消息‘)
    data=tcp_client.recv(buffer_size)
    print(‘客户端发来的消息是‘,data.decode(‘utf_8‘))

client

2:基于udp套接字

from socket import *
ip_port=(‘127.0.0.1‘,8080)
buffer_size=1024

udp_server=socket(AF_INET,SOCK_DGRAM) #数据报
udp_server.bind(ip_port)

while True:
    data,addr=udp_server.recvfrom(buffer_size)  #接收元祖的形式
    print(data)

    udp_server.sendto(data.upper(),addr)

udp_server

from socket import *
ip_port=(‘127.0.0.1‘,8080)
buffer_size=1024

udp_client=socket(AF_INET,SOCK_DGRAM) #数据报

while True:
    msg=input(‘>>>: ‘).strip
    udp_client.sendto(msg.encode(‘utf-8‘),ip_port)

    data,addr=udp_client.recvfrom(buffer_size)
    print(data.decode(‘utf-8‘))

udp_client

3:ntp

from socket import *
import time
ip_port=(‘127.0.0.1‘,8087)
buffer_size=1024

udp_server=socket(AF_INET,SOCK_DGRAM) #数据报
udp_server.bind(ip_port)

while True:
    data,addr=udp_server.recvfrom(buffer_size)  #接收元祖的形式
    print(data)
    if not data:
        fmt=‘%Y-%m-%d %X‘
    else:
        fmt=data.decode(‘utf-8‘)

    back_time=time.strftime(fmt)
    udp_server.sendto(back_time.encode(‘utf-8‘),addr)

ntp_server

from socket import *
ip_port=(‘127.0.0.1‘,8087)
buffer_size=1024

udp_client=socket(AF_INET,SOCK_DGRAM) #数据报

while True:
    msg=input(‘>>>:‘).strip
    udp_client.sendto(msg.encode(‘utf-8‘),ip_port)

    data,addr=udp_client.recvfrom(buffer_size)
    print(data.decode(‘utf-8‘))

ntp_client

四：recv与recvfrom的区别

1.tcp协议：

（1）如果收消息缓冲区里的数据为空，那么recv就会阻塞

（2）tcp基于链接通信，如果一端断开了链接，那另外一端的链接也跟着完蛋recv将不会阻塞，收到的是空

2.udp协议

（1）如果如果收消息缓冲区里的数据为“空”，recvfrom不会阻塞

（2）recvfrom收的数据小于sendinto发送的数据时，数据丢失

（3）只有sendinto发送数据没有recvfrom收数据，数据丢失

tcp/udp总结：

1.udp的sendinto不用管是否有一个正在运行的服务端，可以己端一个劲的发消息

2.udp的recvfrom是阻塞的，一个recvfrom(x)必须对一个一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠.

3.tcp的协议数据不会丢，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。

五：粘包   须知：只有TCP有粘包现象，UDP永远不会粘包

粘包原因：发送端一K一k地发送数据，而接收端不确定收多少数据，TCP是面向流的协议，出现粘包

而UDP是面向消息的协议，无链接。接收端的套接字缓冲区采用链式结构来记录每一个到达的UDP包

TCP基于流，收发的消息不能为空，而 UDP是基于数据报的，即便是空格也不是空消息

两种情况下会发生粘包。

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

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

粘包解决：①：low方式

import socket,subprocess
ip_port=(‘127.0.0.1‘,8080)
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

s.bind(ip_port)
s.listen(5)

while True:
    conn,addr=s.accept()
    print(‘客户端‘,addr)
    while True:
        msg=conn.recv(1024)
        if not msg:break
        res=subprocess.Popen(msg.decode(‘utf-8‘),shell=True,                            stdin=subprocess.PIPE,                         stderr=subprocess.PIPE,                         stdout=subprocess.PIPE)
        err=res.stderr.read()
        if err:
            ret=err
        else:
            ret=res.stdout.read()
        data_length=len(ret)
        conn.send(str(data_length).encode(‘utf-8‘))
        data=conn.recv(1024).decode(‘utf-8‘)
        if data == ‘recv_ready‘:
            conn.sendall(ret)
    conn.close()

server

import socket,time
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex((‘127.0.0.1‘,8080))

while True:
    msg=input(‘>>: ‘).strip()
    if len(msg) == 0:continue
    if msg == ‘quit‘:break

    s.send(msg.encode(‘utf-8‘))
    length=int(s.recv(1024).decode(‘utf-8‘))
    s.send(‘recv_ready‘.encode(‘utf-8‘))
    send_size=0
    recv_size=0
    data=b‘‘
    while recv_size < length:
        data+=s.recv(1024)
        recv_size+=len(data)

    print(data.decode(‘utf-8‘))

client

②：new方法

#socket_server_tcp
from socket import *
import subprocess
import struct
ip_port=(‘222.28.46.49‘,8087)
back_log=5
buffer_size=1024

tcp_server=socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)

while True:
    conn,addr=tcp_server.accept()
    print(‘新的客户端连接‘,addr)
    while True:
        try:
            cmd=conn.recv(buffer_size)
            print(‘收到客户端的命令‘,cmd)

            res=subprocess.Popen(cmd.decode(‘utf-8‘),shell=True,
                                 stderr=subprocess.PIPE,
                                 stdin=subprocess.PIPE,
                                 stdout=subprocess.PIPE)
            err=res.stderr.read()
            if err:
                cmd_res=err
            else:
                cmd_res=res.stdout.read()

            if not cmd_res:
                cmd_res=‘执行成功‘.encode(‘gbk‘)

            length=len(cmd_res)
            # conn.send(str(length)).encode(‘utf-8‘)
            # client_read=conn.recv(buffer_size)
            # if client_read == b‘read‘:
            data_length=struct.pack(‘i‘,length)
            conn.send(data_length)
            conn.send(cmd_res)
        except Exception as e:
            print(e)
            break
    conn.close()

#socket_client_tcp
from socket import *
from functools import partial
import struct
ip_port=(‘222.28.46.49‘,8087)
back_log=5
buffer_size=1024

tcp_client=socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)

while True:
    cmd=input(‘>>>:‘).strip()
    if not cmd:continue
    if cmd == ‘quit‘:break

    tcp_client.send(cmd.encode(‘utf-8‘))

    #解决low粘包
    # length=tcp_client.recv(buffer_size)
    # tcp_client.send(b‘ready‘)
    #
    # length=int(length.decode(‘utf-8‘))
    # recv_size=0
    # recv_msg=b‘‘
    # while recv_size < length:
    #     recv_msg+=tcp_client.recv(buffer_size)
    #     recv_size=len(recv_msg)

    #new------------
    length_data=tcp_client.recv(4)
    length=struct.unpack(‘i‘,length_data)[0]
    recv_msg=‘‘.join(iter(partial(tcp_client.recv,buffer_size),b‘‘))

    print(‘命令的执行结果是‘,recv_msg.decode(‘gbk‘))
tcp_client.close()