第五模块：网络编程    

一：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 socketsocket.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=5buffer_size=1024tcp_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()

from socket import *ip_port=('127.0.0.1',8086)back_log=5buffer_size=1024tcp_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'))

2:基于udp套接字

from socket import *ip_port=('127.0.0.1',8080)buffer_size=1024udp_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)

from socket import *ip_port=('127.0.0.1',8080)buffer_size=1024udp_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'))

3:ntp

from socket import *import timeip_port=('127.0.0.1',8087)buffer_size=1024udp_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)

from socket import *ip_port=('127.0.0.1',8087)buffer_size=1024udp_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'))

四：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,subprocessip_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()

import socket,times=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'))

②：new方法

#socket_server_tcpfrom socket import *import subprocessimport structip_port=('222.28.46.49',8087)back_log=5buffer_size=1024tcp_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_tcpfrom socket import *from functools import partialimport structip_port=('222.28.46.49',8087)back_log=5buffer_size=1024tcp_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()