Socket网络编程

一、网络通信三要素

A:IP地址   (1) 用来标识网络上一台独立的主机

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

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

B:端口号:  (1) 用于标识进程的逻辑地址。不同的进程都有不同的端口标识。

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

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

①、UDP：User Datagram Protocol用户数据报协议

特点：

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

 

 ②、TCP：Transmission Control Protocol传输控制协议

 特点：

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

注意：在TCP/IP协议中，TCP协议通过三次握手建立一个可靠的连接

网络通讯步骤：

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

二、Socket编程

2.1 我们可以利用ip地址＋协议＋端口号唯一标示网络中的一个进程。能够唯一标示网络中的进程后，它们就可以利用socket进行通信了，我们经常把socket翻译为套接字，socket是在应用层和传输层(TCP/IP协议族通信)之间的一个抽象层，是一组接口，它把TCP/IP层复杂的操作抽象为几个简单的接口供应用层调用已实现进程在网络中通信。

　　应用程序两端通过“套接字”向网络发出请求或者应答网络请求。可以把socket理解为通信的把手（hand）

2.2 socket通信流程：

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

2.3 相关方法及参数介绍

 1 sk.bind(address)
 2 
 3 　　#sk.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。
 4 
 5 sk.listen(backlog)
 6 
 7 　　#开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。
 8 
 9 sk.setblocking(bool)
10 
11 　　#是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。
12 
13 sk.accept()
14 
15 　　#接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。
16 
17 　　#接收TCP 客户的连接（阻塞式）等待连接的到来
18 
19 sk.connect(address)
20 
21 　　#连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。
22 
23 sk.connect_ex(address)
24 
25 　　#同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061
26 
27 sk.close()
28 
29 　　#关闭套接字
30 
31 sk.recv(bufsize[,flag])
32 
33 　　#接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。
34 
35 sk.recvfrom(bufsize[.flag])
36 
37 　　#与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。
38 
39 sk.send(string[,flag])
40 
41 　　#将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。
42 
43 sk.sendall(string[,flag])
44 
45 　　#将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。
46 
47       #内部通过递归调用send，将所有内容发送出去。
48 
49 sk.sendto(string[,flag],address)
50 
51 　　#将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。
52 
53 sk.settimeout(timeout)
54 
55 　　#设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）
56 
57 sk.getpeername()
58 
59 　　#返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。
60 
61 sk.getsockname()
62 
63 　　#返回套接字自己的地址。通常是一个元组(ipaddr,port)
64 
65 sk.fileno()
66 
67 　　#套接字的文件描述符
Method

 

 2.4 server下的方法：　　　　　　　　client下的方法：

　　　　bind()　　　　　　　　　　　　　　connect()

　　　　listen()　　　　　　　　　　　　　  recv()

　　　　accept()　　　　　　　　　　　　   send()

　　　　recv()　　　　　　　　　　　　　　sendall()

　　　　send()

　　　　sendall()

　　注：a. recv()理论数据不超过8k，一般用1024。

　　　　b. recv()和send()中的参数类型是bytes类型。一般通过utf8编码格式转换，如果传输的数据中含有汉字，则需要通过gbk转换。

 　　　  例：sk.send(bytes(inp,'utf8'))　　print(str(conn.recv(1024),'utf8'))

2.5 将客户端强制关闭时，若服务端报错，进行try,except处理。

1 try:
2     data = conn.recv(1024)
3 except Exception:
4     break

2.6 远程执行命令

执行命令的一端通过引入subprocess模块实现。

import subprocess
obj = subprocess.Popen(str(data),shell=True,stdout=subprocess.PIPE)
result = obj.stdout.read()
print(str(result,'gbk'))

 

2.7 粘包现象：连续两个sendall时可能会产生此现象。

　　解决方法：用一个 conn.recv(1024) 将两条sendall语句隔断开。

2.8 文件上传

server：

 1 import socket,os
 2 
 3 ip_port = ('127.0.0.1',8099)
 4 sk = socket.socket()
 5 sk.bind(ip_port)
 6 sk.listen(3)
 7 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 8 while True:
 9     print('waiting conect')
10     conn,addr = sk.accept()
11     flag = True
12     while flag:
13         client_bytes = conn.recv(1024)
14         client_str = str(client_bytes,'gbk')
15         func,file_byte_size,filename = client_str.split('|',2)
16         path = os.path.join(BASE_DIR,'aaa',filename)
17         has_received = 0
18         file_byte_size = int(file_byte_size)
19         f = open(path,'wb')
20         while has_received<file_byte_size:
21             data = conn.recv(1024)
22             f.write(data)
23             has_received+=len(data)
24         print('ending')
25         f.close()
server

client:

 1 import socket,re,os,sys
 2 ip_port = ('127.0.0.1',8099)
 3 sk = socket.socket()
 4 sk.connect(ip_port)
 5 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 6 print('客户端启动')
 7 while True:
 8     inp = input('Please input:')
 9     if inp.startswith('post'):
10         method,local_path = inp.split('|',1)
11         local_path = os.path.join(BASE_DIR,local_path)
12         file_byte_size = os.stat(local_path).st_size
13         file_name = os.path.basename(local_path)
14         post_info = 'post|%s|%s'%(file_byte_size,file_name)
15         sk.sendall(bytes(post_info,'gbk'))
16         has_sent = 0
17         file_obj = open(local_path,'rb')
18         while has_sent<file_byte_size:
19             data = file_obj.read(1024)
20             sk.sendall(data)
21             has_sent += len(data)
22         file_obj.close()
23         print('上传成功')
client

2.9 server端并发聊天

server：

 1 import socketserver
 2 class MyServer(socketserver.BaseRequestHandler):
 3     def handle(self):
 4         print('服务端启动。。。')
 5         while True:
 6             conn = self.request
 7             print(self.client_address)
 8             while True:
 9                 client_data = conn.recv(1024)
10                 print(str(client_data,'utf8'))
11                 print('waiting...')
12                 conn.sendall(client_data)
13             conn.close()
14 if __name__ == '__main__':
15     # 创建socket连接
16     server = socketserver.ThreadingTCPServer(('127.0.0.1',8091),MyServer)
17     server.serve_forever()
server

client：

 1 import socket
 2 ip_port = ('127.0.0.1',8091)
 3 sk = socket.socket()
 4 sk.connect(ip_port)
 5 print('客户端启动')
 6 while True:
 7     inp = input('>>>')
 8     sk.sendall(bytes(inp,'utf8'))
 9     if inp == 'exit':
10         break
11     server_response = sk.recv(1024)
12     print(str(server_response,'utf8'))
13 sk.close()
client

2.10 socketserver

SocketServer模块简化了编写网络服务程序的任务。同时SocketServer模块也是Python标准库中很多服务器框架的基础。

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

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

 

posted @ 2018-07-19 22:31  Hme  阅读(284)  评论(0)  编辑  收藏  举报