Python基础12 - Socket网络编程

一、计算机网络

网络通信要素：

1、IP地址：A.用来标识网络上一台独立的主机

　　　　　 B.IP地址 = 网络地址 + 主机地址（网络号：用于识别主机所在的网络/网段。主机号：用于识别该网络中的主机）

　　　　　 C.特殊的IP地址:127.0.0.1（本地回环地址、保留地址，点分十进制）可用于简单的测试网卡是否故障。表示本机。

2、端口号：A.用于标识进程的逻辑地址。不同的进程都有不同的端口标识。

　　　　　 B.端口：要将数据发送到对方指定的应用程序上，为了标识这些应用程序，所以给这些网络应用程序都用数字进行标识。为了方便称呼这些数字，则将这些数字称为端口。（此端口是一个逻辑端口）

3、传输协议：通讯的规则。例如：TCP、UDP协议

UDP:User Datagram Protocol用户数据报协议

特点：

• 面向无连接：传输数据之前源端和目的端不需要建立连接
• 每个数据报的大小都限制在64K(8个字节)以内
• 面向报文的不可靠协议。(即：发送出去的数据不一定会接收得到)
• 传输速率快，效率高
• 现实生活实例：邮局寄件、实时在线聊天、视频会议...等

TCP:Transmission Control Protocol传输控制协议

特点：

• 面向连接：传输数据之前需要建立连接
• 在连接过程中进行大量数据传输
• 通过"三次握手"的方式完成连接，是安全可靠协议
• 传输速度慢，效率低

网络通讯步骤：

　　确定对端IP地址→ 确定应用程序端口 → 确定通讯协议　

　　总结：网络通讯的过程其实就是一个（源端）不断封装数据包和（目的端）不断拆数据包的过程。

　　简单来说就是：发送方利用应用软件将上层应用程序产生的数据前后加上相应的层标识不断的往下层传输（封包过程），最终到达物理层通过看得见摸得着的物理层设备，例如：网线、光纤…等将数据包传输到数据接收方，然后接收方则通过完全相反的操作不断的读取和去除每一层的标识信息（拆包过程），最终将数据传递到最高层的指定的应用程序端口，并进行处理。

二、Socket编程

socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄，应用程序通常通过"套接字"向网络发出请求或者应答网络请求。

socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，对于文件用[打开][读写][关闭]模式来操作。socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作(读/写IO、打开、关闭)

socket和file的区别：

• file模块是针对某个指定文件进行[打开][读写][关闭]
• socket模块是针对 服务器端 和 客户端Socket 进行[打开][读写][关闭]

建立一个socket必须至少有2端，一个服务端，一个客户端，服务端被动等待并接收请求，客户端主动发起请求，连接建立之后，双方可以互发数据。

 1 # 服务器端
 2 import socket
 3 
 4 sk = socket.socket()
 5 sk.bind((‘127.0.0.1‘,6969)) # 绑定要监听端口
 6 sk.listen(5) #监听
 7 print(‘开始监听了‘)
 8 while True:
 9     conn,addr = sk.accept() # 等电话打进来
10     # conn就是客户端连过来而在服务器端为其生成的一个连接实例
11     print(conn,addr)
12     while True:
13         data = conn.recv(1024)
14         print(‘recv:‘,data.decode())
15         if not data:
16             print(‘client has lost....‘)
17             break
18         msg = input(‘>>:‘).strip()
19         conn.send(msg.encode(‘utf-8‘))

socket_server

 1 # 客户端
 2 import socket
 3 
 4 client = socket.socket() # 声明socket类型，同时生成socket连接对象
 5 client.connect((‘127.0.0.1‘,6969))
 6 
 7 while True:
 8     msg = input(‘>>:‘).strip()
 9     if len(msg) == 0:continue
10     client.send(msg.encode(‘utf-8‘))
11     data = client.recv(1024)
12     print(‘recv:‘,data.decode())
13 
14 client.close()

socket_client

三、Socket方法

1、sk = socket.socket(family=AF_TNET,type=SOCK_STREAM,proto=0,fileno=None)

参数一：地址簇

　　socket.AF_INET　　IPv4(默认)
　　socket.AF_INET6　 IPv6
　　socket.AF_UNIX　　只能够用于单一的Unix系统进程间通信

参数二：类型

　　socket.SOCK_STREAM　　流式socket，for TCP(默认)
　　socket.SOCK_DGRAM　　 数据报式socket，for UDP
　　socket.SOCK_RAW　　   原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。
　　socket.SOCK_SEQPACKET　可靠的连接数据包服务

参数三：协议

　　0　　(默认)与特定的地址家族相关的协议，如果是0，则系统就会根据地址格式和套接类别，自动选择一个合造的协议

2、sk.bind(address)

　　sk.bind(address)将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组(host,port)的形式表示地址

3、sk.listen(backlog)

　　开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。

　　backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5。这个值不能无限大，因为要在内核中维护连接队列

4、sk.setblocking(bool)

　　是否阻塞(默认True)，如果设置False，那么accept和recv时一旦无数据，则报错

5、sk.accept()

　　接受连接并返回(conn,address)，其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。

　　接收TCP客户的连接(阻塞式)等待连接的到来

6、sk.connect(address)

　　连接到address处的套接字。一般，address的格式为元组(hostname,port)，如果连接出错，返回socket.error错误

7、sk.connect_ex(address)

　　同上，只不过会有返回值，连接成功时返回0，连接失败时候返回编码，例如：10061

8、sk.close()

　　关闭套接字

9、sk.recv(bufsize[,flag])

　　接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。

10、sk.recvfrom(bufsize[,flag])

　　与recv()类似，但返回值是(data,address)。其中data是包含接收数据的字符串，address是发送数据的套接字地址

11、sk.send(string[,flag])

　　将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送

12、sk.sendall(string[,flag])

　　将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。

　　内部通过递归调用send，将所有内容发送出去

13、sk.sendto(string[,flag],address)

　　将数据发送到套接字，address是形式为(ipaddr,port)的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议

14、sk.settimeout(timeout)

　　设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般。超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作(如client连接最多等待5s)

15、sk.getpeername()

　　返回连接套接字的远程地址。返回值通常是元组(ipaddr,port)

16、sk.getsockname()

　　返回套接字自己的地址。通常是一个元组(ipaddr,port)

17、sk.fileno()

　　套接字的文件描述符

18、socket.sendfile(file,offset=0,count=None)

　　发送文件，但目前多数情况下不用

实例：命令传送

 1 # 服务端
 2 import socket , os
 3 
 4 sk = socket.socket()
 5 sk.bind((‘localhost‘,9999))
 6 sk.listen(5)
 7 while True:
 8     conn,addr = sk.accept()
 9     print(addr)
10     while True:
11         try:
12             print(‘等待新指令‘)
13             data = conn.recv(1024)
14         except Exception:
15             break
16         if not data:
17             print(‘客户端已断开‘)
18             break
19         print(‘执行指令:‘,data)
20         cmd_res = os.popen(data.decode()).read() # 接受字符串，执行结果也是字符串
21         # print(len(cmd_res))
22         if len(cmd_res) == 0:
23             cmd_res = ‘命令不存在‘
24         conn.send(str(len(cmd_res.encode())).encode(‘utf-8‘)) # 先发大小给客户端
25         conn.recv(1024) # 解决粘包现象
26         conn.send(cmd_res.encode(‘utf-8‘))
27 
28 sk.close()

 1 # 客户端
 2 import socket
 3 
 4 client = socket.socket()
 5 client.connect((‘localhost‘,9999))
 6 while True:
 7     cmd = input(‘>>:‘).strip()
 8     if len(cmd) == 0:continue
 9     client.send(cmd.encode(‘utf-8‘))
10     cmd_size = client.recv(1024) # 接受命令结果的长度
11     print(‘命令结果大小:‘,cmd_size)
12     client.send(‘ok‘.encode(‘utf-8‘)) # 接收完命令长度，发送ok解决粘包
13     rec_size = 0
14     rec_data = bytes()
15     while rec_size < int(cmd_size.decode()):
16         data = client.recv(1024)
17         rec_size += len(data) # 每次收到的有可能小于1024，所以必须用len判断
18         rec_data += data
19     else:
20         print(‘接收命令大小:‘,rec_size)
21         print(rec_data.decode())
22 
23 client.close()

结论：

　　sendall会把数据直接全部发送到客户端，客户端将所有的数据都放到缓冲区，每次recv多少字节取决于recv内的参数，官方建议不应该超过8K。所以，并不能一次recv()无限大数据，这里我们应该通过循环去接收。

文件上传

 1 import hashlib
 2 import socket , os
 3 
 4 sk = socket.socket()
 5 sk.bind((‘0.0.0.0‘,9999))
 6 sk.listen(5)
 7 
 8 while True:
 9     conn,addr = sk.accept()
10     print(‘conn:‘,addr)
11     while True:
12         try:
13             print(‘等待新指令‘)
14             data = conn.recv(1024)
15         except Exception:break
16         if not data:break
17         cmd,filename = data.decode().split()
18         print(filename)
19         if os.path.isfile(filename):
20             f = open(filename,‘rb‘)
21             m = hashlib.md5()
22             file_size = os.stat(filename).st_size
23             conn.send(str(file_size).encode(‘utf-8‘))
24             conn.recv(1024)
25             for line in f:
26                 m.update(line)
27                 conn.send(line)
28             f.close()
29             conn.send(m.hexdigest().encode(‘utf-8‘))
30         print(‘send done‘)
31 sk.close()

FTP_server

 1 import socket
 2 import hashlib
 3 
 4 client = socket.socket()
 5 client.connect((‘127.0.0.1‘,9999))
 6 
 7 while True:
 8     cmd = input(‘>>:‘).strip()
 9     if len(cmd) == 0:continue
10     if cmd.startswith(‘get‘):
11         client.send(cmd.encode(‘utf-8‘))
12         sk_response = client.recv(1024)
13         print(‘sk‘,sk_response)
14         client.send(b‘ok‘)
15         file_total_size = int(sk_response.decode())
16         received_size = 0
17         filename = cmd.split()[1]
18         f = open(filename + ".new",‘wb‘)
19         m = hashlib.md5()
20 
21         while received_size < file_total_size:
22             if file_total_size - received_size > 1024:
23                 size = 1024
24             else:
25                 size = file_total_size - received_size
26             data = client.recv(size)
27             received_size += len(data)
28             m.update(data)
29             f.write(data)
30         else:
31             new_file_md5 = m.hexdigest()
32             print(‘file recv done‘,received_size,file_total_size)
33         sk_file_md5 = client.recv(1024)
34         print(‘server file md5:‘,sk_file_md5)
35         print(‘client file md5:‘,new_file_md5)
36 client.close()

FTP_client

四、socketserver

SocketServer内部使用IO多路复用以及"多线程"和"多进程"，从而实现并发处理多个客户端请求的Socket服务端。即：每个客户端请求连接到服务器时，Socket服务端都会在服务器是创建一个"线程"或者"进程"专门负责处理当前客户端的所有请求。

socketserver模块可以简化网络服务器的编写，Python把网络服务抽象成两个主要的类，一个是Server类，用于处理连接相关的网络操作，另外一个则是RequestHandler类,用于处理数据相关的操作。并且提供两个Mixln类，用于扩展Server,实现多进程或多线程。

Server类

 Server类以五种：BaseServer(不直接对外服务)、TCPServer使用TCP协议、UDPServer使用UDP协议、还有两个不常使用的，即UnixStreamServer和UnixDatagramServer，这两个类仅仅在unix环境下有用(AF_unix)

There are five classes in an inheritance diagram, four of which represent synchronous servers of four types:

RequestHandler类

所有RequestHandler都继承BaseRequestHandler基类

创建一个socketserver至少分以下几步

1. First, you must create a request handler class by subclassing the BaseRequestHandlerclass and overriding its handle() method; this method will process incoming requests.(首先，您必须通过子类化BaseRequestHandlerclass并覆盖它的handle()方法来创建一个请求处理程序类;这个方法将处理传入的请求) 　　
2. Second, you must instantiate one of the server classes, passing it the server’s address and the request handler class.(其次，必须实例化一个服务器类，将其传递到服务器的地址和请求处理程序类)
3. Then call the handle_request() orserve_forever() method of the server object to process one or many requests.(然后调用服务器对象的handlerequest()或serve永存()方法来处理一个或多个请求)
4. Finally, call server_close() to close the socket.(最后，调用serverclose()来关闭套接字)

 1 # 服务器
 2 import socketserver
 3 
 4 class MyServer(socketserver.BaseRequestHandler):
 5     ‘‘‘
 6     服务器的请求处理程序类
 7     它在每个连接到服务器的连接上被实例化，并且必须覆盖句柄()方法来实现对客户机的通信
 8     ‘‘‘
 9     def handle(self):
10         while 1:
11             try:
12                 self.data = self.request.recv(1024).strip()
13                 if not self.data:break
14                 print(‘{}wrote:‘.format(self.client_address[0]))
15                 print(self.data)
16                 self.request.sendall(self.data.upper())
17             except ConnectionResetError:break
18 
19 if __name__ == ‘__main__‘:
20     HOST, PORT = ‘localhost‘,9999
21 
22     server = socketserver.TCPServer((HOST,PORT),MyServer)
23     server.serve_forever()

 1 # 客户端
 2 import socket
 3 
 4 client =socket.socket()
 5 client.connect((‘localhost‘,9999))
 6 
 7 while 1:
 8     inp = input(‘>>:‘).strip()
 9     if len(inp)==0:continue
10     client.send(inp.encode(‘utf-8‘))
11     data = client.recv(1024)
12     print(data.decode())
13 client.close()

让你的socketserver并发起来，必须选择使用以下一个多并发的类

1 class socketserver.ForkingTCPServer
2  
3 class socketserver.ForkingUDPServer
4  
5 class socketserver.ThreadingTCPServer
6  
7 class socketserver.ThreadingUDPServer

上面这个例子你会发现，依然不能实现多并发，所以：

把 

 1 server = socketserver.TCPServer((HOST, PORT), MyServer) 

改成

 1 server = socketserver.ThreadingTCPServer((HOST,PORT),MyServer)