Python socket网络编程--总结

1 引入socket

1.1 客户端/服务器架构

即C/S架构，包括

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

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

生活中的C/S架构：

• 老男孩是S端，所有的学员是C端

• 饭店是S端，所有的食客是C端

• 互联网中处处是C/S架构（网站是服务端，你的浏览器是客户端；腾讯作为服务端为你提供视频，你得下个腾讯视频客户端才能看狗日的视频）

C/S架构与socket的关系：

我们学习socket就是为了完成C/S架构的开发

最常用的软件服务器是 Web 服务器。一台机器里放一些网页或 Web 应用程序,然后启动 服务。

这样的服务器的任务就是接受客户的请求,把网页发给客户(如用户计算机上的浏览器),然 后等待下一个客户请求。

这些服务启动后的目标就是“永远运行下去”。虽然它们不可能实现这样的 目标,但只要没有关机或硬件出错等外力干扰,它们就能运行非常长的一段时间。

1.2 osi七层模型

引子：

须知一个完整的计算机系统是由硬件、操作系统、应用软件三者组成,具备了这三个条件，一台计算机系统就可以自己跟自己玩了（打个单机游戏，玩个扫雷啥的）

如果你要跟别人一起玩，那你就需要上网了（访问个网站，发个微博啥的），互联网的核心就是由一堆协议组成，协议就是标准，全世界人通信的标准是英语，如果把计算机比作人，互联网协议就是计算机界的英语。

所有的计算机都学会了互联网协议，那所有的计算机都就可以按照统一的标准去收发信息从而完成通信了。

人们按照分工不同把互联网协议从逻辑上划分了层级，详见我另一篇博客http://www.cnblogs.com/linhaifeng/articles/5937962.html

为何学习socket一定要先学习互联网协议：

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

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

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

• 最后：就让我们从这些标准开始研究，开启我们的socket编程之旅

1.3 socket层

在上图中，我们没有看到Socket的影子，那么它到底在哪里呢？还是用图来说话，一目了然。

1.4 socket是什么

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

所以，我们无需深入理解tcp/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。

也有人将socket说成ip+port，ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序，ip地址是配置到网卡上的，而port是应用程序开启的，ip与port的绑定就标识了互联网中独一无二的一个应用程序

而程序的pid是同一台机器上不同进程或者线程的标识

1.5 套接字发展史及分类

套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。 因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。

基于文件类型的套接字家族

套接字家族的名字：AF_UNIX

unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信

基于网络类型的套接字家族

套接字家族的名字：AF_INET

(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)

1.6 套接字工作流程

先从服务器端说起。服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束

2 基于tcp协议的套接字

2.1 基于tcp协议简单实现

socket server：

#!/usr/bin/env python
# __Author__: "wanyongzhen"
# Date: 2017/5/3

import socket  # 导入socket模块
# 类似生活中的打电话
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) # 买手机
phone.bind(('127.0.0.1',8080))   # 绑定手机卡
phone.listen(5)                  # 开机
conn,addr = phone.accept()       # 等待电话链接
print('client conn is ',conn)    # 打印电话线路
print('client addr is ',addr)    # 打印客户端地址
data = conn.recv(1024)           # 收消息
print('client send a message',data)  # 打印消息
conn.send(data.upper())          # 回消息
conn.close()                     # 挂电话
phone.close()                    # 关机

socket client:

#!/usr/bin/env python
# __Author__: "wanyongzhen"
# Date: 2017/5/3

import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)   # 买手机
phone.connect(('127.0.0.1',8080))   # 直接打电话,发起链接
msg = input('>>: ').strip()         # 输入消息
phone.send(msg.encode())            # 发送消息
data = phone.recv(1024)             # 接收消息
print(data.decode())                # 打印消息
phone.close()                       # 关机

2.2 基于tcp协议简单实现改进

server ：

#!/usr/bin/env python
# __Author__: "wanyongzhen"
# Date: 2017/5/3

import socket  # 导入socket模块
# 类似生活中的打电话
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) # 买手机
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) # 端口重用
# 运维层面解决端口重用
# 发现系统存在大量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 时间

phone.bind(('127.0.0.1',8080))   # 绑定手机卡 (绑定IP 端口)
phone.listen(5)                  # 开机  (TCP的半链接池或暂存池大小)
while True:  # 链接循环
    conn,addr = phone.accept()       # 等待电话链接
    print('client conn is ',conn)    # 打印电话线路
    print('client addr is ',addr)    # 打印客户端地址
    while True:   # 通信循环
        try:  # 应对Windows系统
            data = conn.recv(1024)           # 收消息 (从缓存中收取消息)(每次收取的消息大小为1024字节)
            if not data: break  # 应对Linux系统
            print('client send a message',data)  # 打印消息
            conn.send(data.upper())          # 回消息
        except Exception:
            break
    conn.close()                     # 挂电话
phone.close()                    # 关机

client:

#!/usr/bin/env python
# __Author__: "wanyongzhen"
# Date: 2017/5/3

import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)   # 买手机
phone.connect(('127.0.0.1',8080))   # 直接打电话,发起链接
while True:   # 通信循环
    msg = input('>>: ').strip()         # 输入消息
    phone.send(msg.encode('utf-8'))            # 发送消息(发送到缓存中,并由操作系统发送到服务端缓存中)
    data = phone.recv(1024)             # 接收消息
    print(data.decode())                # 打印消息
phone.close()                       # 关机

2.3 粘包

2.3.1 粘包现象

server:

#!/usr/bin/env python
# __Author__: "wanyongzhen"
# Date: 2017/5/3

import socket
# 须知：只有TCP有粘包现象，UDP永远不会粘包
# 所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。
# 此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。
# 若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) # 端口重用
phone.bind(('127.0.0.1',8080))
phone.listen(5)
conn,addr = phone.accept()

# 粘包现象1
# data1 = conn.recv(1024)
# data2 = conn.recv(1024)
# print(data1) # 收到粘包数据 b'helloworldSB'
# print(data2) # 收到空数据 b''

# 粘包现象2(基于客户端的:解决粘包现象1)
data1 = conn.recv(2)
data2 = conn.recv(1024)
print(data1) # 收到两个字节数据 b'he'
print(data2) # 收到粘包数据 b'lloworld' 没收到b'SB'

client:

#!/usr/bin/env python
# __Author__: "wanyongzhen"
# Date: 2017/5/3

import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)   # 买手机
phone.connect(('127.0.0.1',8080))   # 直接打电话,发起链接
# 以下两条消息被合并成一条数据发送到服务器端
phone.send('helloworld'.encode('utf-8'))

# 解决粘包现象1
# import time
# time.sleep(3) # 通过time.sleep()简单解决粘包问题
phone.send('SB'.encode('utf-8'))

2.3.2 解决粘包

server:

#!/usr/bin/env python
# __Author__: "wanyongzhen"
# Date: 2017/5/3

import socket  # 导入socket模块
import subprocess
# 类似生活中的打电话
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) # 买手机
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) # 端口重用
phone.bind(('127.0.0.1',8080))   # 绑定手机卡 (绑定IP 端口)
phone.listen(5)                  # 开机  (TCP的半链接池或暂存池大小)

# while True:  # 链接循环
#     conn,addr = phone.accept()       # 等待电话链接
#     print('client conn is ',conn)    # 打印电话线路
#     print('client addr is ',addr)    # 打印客户端地址
#     while True:   # 通信循环
#         try:  # 应对Windows系统
#             cmd = conn.recv(1024)           # 收消息 (从缓存中收取消息)(每次收取的消息大小为1024字节)
#             if not cmd: break  # 应对Linux系统
#             res = subprocess.Popen(cmd.decode('utf-8'),
#                              shell=True,
#                              stderr=subprocess.PIPE,
#                              stdout=subprocess.PIPE)
#
#             conn.send(res.stderr.read())     # 回消息
#             conn.send(res.stdout.read())     # 回消息
#         except Exception:
#             break
#     conn.close()                     # 挂电话
# phone.close()                    # 关机

# # 自定义报头解决粘包
# import struct
# while True:  # 链接循环
#     conn,addr = phone.accept()       # 等待电话链接
#     print('client conn is ',conn)    # 打印电话线路
#     print('client addr is ',addr)    # 打印客户端地址
#     while True:   # 通信循环
#         try:  # 应对Windows系统
#             cmd = conn.recv(1024)           # 收消息 (从缓存中收取消息)(每次收取的消息大小为1024字节)
#             if not cmd: break  # 应对Linux系统
#             res = subprocess.Popen(cmd.decode('utf-8'),
#                              shell=True,
#                              stderr=subprocess.PIPE,
#                              stdout=subprocess.PIPE)
#             out_res = res.stdout.read()
#             err_res = res.stderr.read()
#             data_size = len(out_res) + len(err_res)
#             # 发送报头
#             conn.send(struct.pack('i',data_size))
#             # 发送数据
#             conn.send(out_res)     # 回消息
#             conn.send(err_res)     # 回消息
#         except Exception:
#             break
#     conn.close()                     # 挂电话
# phone.close()                    # 关机

# 自定义json报头解决粘包
import struct
import json
while True:  # 链接循环
   conn,addr = phone.accept()       # 等待电话链接
   print('client conn is ',conn)    # 打印电话线路
   print('client addr is ',addr)    # 打印客户端地址
   while True:   # 通信循环
       try:  # 应对Windows系统
           cmd = conn.recv(1024)           # 收消息 (从缓存中收取消息)(每次收取的消息大小为1024字节)
           if not cmd: break  # 应对Linux系统
           res = subprocess.Popen(cmd.decode('utf-8'),
                            shell=True,
                            stderr=subprocess.PIPE,
                            stdout=subprocess.PIPE)
           out_res = res.stdout.read()
           err_res = res.stderr.read()
           data_size = len(out_res) + len(err_res)
           header_dict = {'length':data_size,'filename':None}
           header_json = json.dumps(header_dict)
           header_bytes = header_json.encode('utf-8')
           header_len = len(header_bytes)
           # 发送json header长度
           conn.send(struct.pack('i',header_len))
           # 发送json header
           conn.send(header_bytes)
           # 发送数据
           conn.send(out_res)     # 回消息
           conn.send(err_res)     # 回消息
       except Exception:
           break
   conn.close()                     # 挂电话
phone.close()                    # 关机

client:

#!/usr/bin/env python
# __Author__: "wanyongzhen"
# Date: 2017/5/3

import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)   # 买手机
phone.connect(('127.0.0.1',8080))   # 直接打电话,发起链接

# while True:   # 通信循环
#     cmd = input('>>: ').strip()         # 输入消息
#     if not cmd: continue
#     phone.send(cmd.encode('utf-8'))     # 发送消息(发送到缓存中,并由操作系统发送到服务端缓存中)
#     # 粘包问题:
#     # 当命令输出内容很大时(超过1024字节),客户端不能一次性接受完成
#     # 就会出现这种情况:在下次接受时会收到上次服务器端发送的命令结果
#     # 这就叫粘包
#     data = phone.recv(1024)             # 接收消息
#     print(data.decode('utf-8'))                # 打印消息
# phone.close()                       # 关机


# # 自定义报头解决粘包
# import struct
# while True:   # 通信循环
#     cmd = input('>>: ').strip()         # 输入消息
#     if not cmd: continue
#     phone.send(cmd.encode('utf-8'))     # 发送消息(发送到缓存中,并由操作系统发送到服务端缓存中)
#     # 接收报头
#     header = phone.recv(4)             # 接收消息
#     data_size = struct.unpack('i',header)[0]
#     # 接收数据
#     recv_size = 0
#     recv_data = b''
#     while recv_size < data_size:
#         data = phone.recv(1024)
#         recv_size += len(data)
#         recv_data += data
#     print(recv_data.decode('utf-8'))                # 打印消息
# phone.close()                       # 关机


# 自定义json报头解决粘包
import struct
import json
while True:   # 通信循环
    cmd = input('>>: ').strip()         # 输入消息
    if not cmd: continue
    phone.send(cmd.encode('utf-8'))     # 发送消息(发送到缓存中,并由操作系统发送到服务端缓存中)
    # 接收json header长度
    header_len_json = phone.recv(4)             # 接收消息
    json_len = struct.unpack('i',header_len_json)[0]
    # 接收json header数据
    header_json = phone.recv(json_len)
    header_json = header_json.decode('utf-8')
    header_dict = json.loads(header_json)
    data_size = header_dict['length']
    # 接收数据
    recv_size = 0
    recv_data = b''
    while recv_size < data_size:
        data = phone.recv(1024)
        recv_size += len(data)
        recv_data += data
    print(recv_data.decode('utf-8'))                # 打印消息
phone.close()                  # 关机

3 基于tcp协议的socketserver

server:

#!/usr/bin/env python
# __Author__: "wanyongzhen"
# Date: 2017/5/7

# 服务端特点是:
# 1 一直运行提供服务(链接循环)(基于一个链接通信循环)
# 2 绑定一个唯一的地址

# import socket
# phone = socket.socket()
# phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) # 端口重用
# phone.bind(('127.0.0.1',8080))
# phone.listen(5)
# conn,addr = phone.accept()
# while True:
#     print(conn)
#     msg = input('>>: ')
#     conn.send(msg.encode())

import socketserver

class FTPServer(socketserver.BaseRequestHandler):
    def handle(self):
        print(self.request)
        while True:
            data = self.request.recv(1024)
            print(data)
            self.request.send(data.upper())
if __name__ =='__main__':
    obj = socketserver.ThreadingTCPServer(('127.0.0.1',8081),FTPServer)
    obj.serve_forever() # 链接循环(多线程)

client1:

#!/usr/bin/env python
# __Author__: "wanyongzhen"
# Date: 2017/5/7

import socket

phone = socket.socket()
phone.connect(('127.0.0.1', 8081))

while True:
    msg = input('>>: ')
    phone.send(msg.encode('utf-8'))
    data = phone.recv(1024)
    print(data)

client2:

#!/usr/bin/env python
# __Author__: "wanyongzhen"
# Date: 2017/5/7

import socket

phone = socket.socket()
phone.connect(('127.0.0.1', 8081))

while True:
    msg = input('>>: ')
    phone.send(msg.encode('utf-8'))
    data = phone.recv(1024)
    print(data)

4 基于udp协议的套接字

4.1 基于udp协议简单实现

socket server:

#!/usr/bin/env python
# __Author__: "wanyongzhen"
# Date: 2017/5/6

import socket

udp_server = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
udp_server.bind(('127.0.0.1',8080))

while True:  # 通讯循环
    data,client_addr = udp_server.recvfrom(1024)
    print(data)
    inp = input('>>: ')
    udp_server.sendto(inp.encode('utf-8'),client_addr)

socket client:

#!/usr/bin/env python
# __Author__: "wanyongzhen"
# Date: 2017/5/6

import socket

udp_client = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
server_ip_port = ('127.0.0.1',8080)

while True:  # 通讯循环
    inp = input('>>: ')
    udp_client.sendto(inp.encode('utf-8'),server_ip_port)
    data,server_addr = udp_client.recvfrom(1024)
    print(data)

4.2 基于udp协议socket发送接收数据报测试

socket server:

#!/usr/bin/env python
# __Author__: "wanyongzhen"
# Date: 2017/5/6

import socket

udp_server = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
udp_server.bind(('127.0.0.1',8080))

data,client_addr = udp_server.recvfrom(2)  # udp接收数据以消息为单位,如果接收数据大于2个字节,会只收到前两个字节(Windows会报错)
print(data)
data,client_addr = udp_server.recvfrom(2)  # udp接收数据以消息为单位
print(data)

socket client：

#!/usr/bin/env python
# __Author__: "wanyongzhen"
# Date: 2017/5/6

import socket

udp_client = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
server_ip_port = ('127.0.0.1',8080)


udp_client.sendto('hello'.encode('utf-8'),server_ip_port)
udp_client.sendto('world'.encode('utf-8'),server_ip_port)

基于socketserver实现多线程

socket server：

#!/usr/bin/env python
# __Author__: "wanyongzhen"
# Date: 2017/5/6


import socketserver

class FTPServer(socketserver.BaseRequestHandler):
    def handle(self):
        print(self.request[0])
        print(self.request[1])
        self.request[1].sendto('hehe'.encode('utf-8'),self.client_address)

if __name__ == '__main__':
    obj = socketserver.ThreadingUDPServer(('127.0.0.1',8080),FTPServer)
    obj.serve_forever()

socket client:

#!/usr/bin/env python
# __Author__: "wanyongzhen"
# Date: 2017/5/6

import socket

udp_client = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
server_ip_port = ('127.0.0.1',8080)

while True:  # 通讯循环
    inp = input('>>: ')
    udp_client.sendto(inp.encode('utf-8'),server_ip_port)
    data,server_addr = udp_client.recvfrom(1024)
    print(data)