Python基础-socket编程

一、网络编程

自从互联网诞生以来，现在基本上所有的程序都是网络程序，很少有单机版的程序了。

计算机网络就是把各个计算机连接到一起，让网络中的计算机可以互相通信。网络编程就是如何在程序中实现两台计算机的通信。

举个例子，当你使用浏览器访问新浪网时，你的计算机就和新浪的某台服务器通过互联网连接起来了，然后，新浪的服务器把网页内容作为数据通过互联网传输到你的电脑上。

由于你的电脑上可能不止浏览器，还有QQ、Skype、Dropbox、邮件客户端等，不同的程序连接的别的计算机也会不同，所以，更确切地说，网络通信是两台计算机上的两个进程之间的通信。比如，浏览器进程和新浪服务器上的某个Web服务进程在通信，而QQ进程是和腾讯的某个服务器上的某个进程在通信。

网络编程对所有开发语言都是一样的，Python也不例外。用Python进行网络编程，就是在Python程序本身这个进程内，连接别的服务器进程的通信端口进行通信。

二、c/s架构

C/S又称Client/Server或客户/服务器模式。

Client/Server结构是20世纪80年代末提出的。这种结构的系统把较复杂的计算和管理任务交给网络上的高档机器——服务器，而把一些频繁与用户打交道的任务交给前端较简单的计算机—客户机。通过这种方式，将任务合理分配到客户端和服务器端，既充分利用了两端硬件环境的优势，又实现了网络上信息资源的共享。由于这种结构比较适于局域网运行环境，因此逐渐得到了广泛的应用。

三、Socket是什么

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

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

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

 四、Socket的发展史及分类

Socket的英文原义是“孔”或“插座”。作为BSD UNIX的进程通信机制，取后一种意思。通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。

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

1. 基于文件类型的套接字家族：AF_UNIX
   unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信
2. 基于网络类型的套接字家族：AF_INET
   还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候只使用AF_INET

五、Scoket的工作流程

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

 1 import socket
 2 socket.socket(socket_family,socket_type,protocal=0)
 3 #socket_family 可以是 AF_UNIX 或 AF_INET。socket_type 可以是 SOCK_STREAM 或 SOCK_DGRAM。protocol 一般不填,默认值为 0。
 4
 5 #获取tcp/ip套接字
 6 tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 7
 8 #获取udp/ip套接字
 9 udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
10
11 “”“由于 socket 模块中有太多的属性。我们在这里破例使用了‘from module import *‘语句。使用 ‘from socket import *‘,我们就把 socket 模块里的所有属性都带到我们的命名空间里了,这样能 大幅减短我们的代码。
12 例如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()                 关闭套接字
• 面向锁的套接字方法
  s.setblocking()       设置套接字的阻塞与非阻塞模式
  s.settimeout()        设置阻塞套接字操作的超时时间
  s.gettimeout()        得到阻塞套接字操作的超时时间
• 面向文件的套接字的函数
  s.fileno()              套接字的文件描述符
  s.makefile()         创建一个与该套接字相关的文件

六、基于TCP的Socket

TCP服务端：

 1 ss = socket() 　　　　#创建服务器套接字
 2 ss.bind()      　　  #把地址绑定到套接字
 3 ss.listen()         #监听链接
 4 inf_loop:      　　  #服务器无限循环
 5     cs = ss.accept() #接受客户端链接
 6     comm_loop:         #通讯循环
 7         cs.recv()        #对话(接收)
 8         cs.send()       #对话(发送)
 9     cs.close()    #关闭客户端套接字
10 ss.close()        #关闭服务器套接字(可选)    

TCP客户端：

1 cs = socket()     # 创建客户套接字
2 cs.connect()      # 尝试连接服务器
3 comm_loop:        # 通讯循环
4     cs.send()     # 对话(发送)
5     cs.recv()     # 对话(接收)
6 cs.close()        # 关闭客户套接字

实例1：

 1 #_*_coding:utf-8_*_
 2 __author__ = ‘Linhaifeng‘
 3 import socket
 4 ip_port=(‘127.0.0.1‘,8081)#电话卡（服务器的IP及端口，元组的格式）
 5 BUFSIZE=1024        #指定一次能接收数据的最大容量
 6 s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机
 7 s.bind(ip_port) #手机插卡
 8 s.listen(5)     #手机待机（监听缓存区容量）
 9
10
11 while True:                         #新增接收链接循环,可以不停的接电话
12     conn,addr=s.accept()            #手机接电话
13     # print(conn)
14     # print(addr)
15     print(‘接到来自%s的电话‘ %addr[0])
16     while True:                         #新增通信循环,可以不断的通信,收发消息
17         msg=conn.recv(BUFSIZE)             #听消息,听话
18
19         if len(msg) == 0:break        #如果不加,那么正在链接的客户端突然断开,recv便不再阻塞,死循环发生
20
21         print(msg,type(msg))
22
23         conn.send(msg.upper())          #发消息,说话
24
25     conn.close()                    #挂电话
26
27 s.close()                       #手机关机

服务端

 1 #_*_coding:utf-8_*_
 2 __author__ = ‘Linhaifeng‘
 3 import socket
 4 ip_port=(‘127.0.0.1‘,8081)
 5 BUFSIZE=1024
 6 s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 7
 8 s.connect_ex(ip_port)           #拨电话
 9
10 while True:                             #新增通信循环,客户端可以不断发收消息
11     msg=input(‘>>: ‘).strip()
12     if len(msg) == 0:continue
13     s.send(msg.encode(‘utf-8‘))         #发消息,说话(只能发送字节类型)
14
15     feedback=s.recv(BUFSIZE)                           #收消息,听话
16     print(feedback.decode(‘utf-8‘))
17
18 s.close()                                       #挂电话

客户端

问题：

有的同学在重启服务端时可能会遇到

这个是由于你的服务端仍然存在四次挥手的time_wait状态在占用地址（如果不懂，请深入研究1.tcp三次握手，四次挥手 2.syn洪水攻击 3.服务器高并发情况下会有大量的time_wait状态的优化方法）

解决方法：

1 #加入一条socket配置，重用ip和端口
2
3 phone=socket(AF_INET,SOCK_STREAM)
4 phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加
5 phone.bind((‘127.0.0.1‘,8080))

方法1

 1 发现系统存在大量TIME_WAIT状态的连接，通过调整linux内核参数解决，
 2 vi /etc/sysctl.conf
 3
 4 编辑文件，加入以下内容：
 5 net.ipv4.tcp_syncookies = 1
 6 net.ipv4.tcp_tw_reuse = 1
 7 net.ipv4.tcp_tw_recycle = 1
 8 net.ipv4.tcp_fin_timeout = 30
 9
10 然后执行 /sbin/sysctl -p 让参数生效。
11
12 net.ipv4.tcp_syncookies = 1 表示开启SYN Cookies。当出现SYN等待队列溢出时，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭；
13
14 net.ipv4.tcp_tw_reuse = 1 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭；
15
16 net.ipv4.tcp_tw_recycle = 1 表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭。
17
18 net.ipv4.tcp_fin_timeout 修改系統默认的 TIMEOUT 时间

方法2

实例2：

 1 import socket, threading, time
 2
 3 def tcplink(sock, addr):
 4     """每个连接都必须创建新线程（或进程）来处理，否则，单线程在处理连接的过程中，无法接受其他客户端的连接"""
 5     print(‘Accept new connection from %s: %s‘ % addr)
 6     sock.send(b‘Welcome!‘)
 7     while True:
 8         data = sock.recv(1024)
 9         time.sleep(1)
10         if not data or data.decode(‘utf-8‘) == ‘exit‘:
11             break
12         sock.send((‘Hello, %s!‘ % data.decode(‘utf-8‘)).encode(‘utf-8‘))
13     sock.close()
14     print(‘Connection from %s: %s closed.‘ % addr)
15
16
17 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
18 #监听端口
19 s.bind((‘127.0.0.1‘, 9999))
20 s.listen(5)
21 print(‘Waiting for connection...‘)
22 while True:
23     #接受一个新连接
24     sock, addr = s.accept()
25     #创建新线程来处理TCP连接
26     t = threading.Thread(target=tcplink, args=(sock, addr))
27     t.start()

服务端

 1 import socket
 2
 3 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 4 # 建立连接:
 5 s.connect((‘127.0.0.1‘, 9999))
 6 # 接收欢迎消息:
 7 print(s.recv(1024).decode(‘utf-8‘))
 8 for data in [b‘Michael‘, b‘Tracy‘, b‘Sarah‘]:
 9     # 发送数据:
10     s.send(data)
11     print(s.recv(1024).decode(‘utf-8‘))
12 s.send(b‘exit‘)
13 s.close()
14
15
16 #可同时开多个客户端

客户端

实例3：

 1 # 导入socket库:
 2 import socket
 3
 4 # 创建一个socket:
 5 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 6 # 建立连接:
 7 s.connect((‘www.sina.com.cn‘, 80))
 8 # 发送数据:
 9 s.send(b‘GET / HTTP/1.1\r\nHost: www.sina.com.cn\r\nConnection: close\r\n\r\n‘)
10 #TCP连接创建的是双向通道，双方都可以同时给对方发数据。但是谁先发谁后发，怎么协调，要根据具体的协议来决定。
11 # 例如，HTTP协议规定客户端必须先发请求给服务器，服务器收到后才发数据给客户端。
12
13 # 接收数据:
14 buffer = []
15 while True:
16     # 每次最多接收1k字节:
17     d = s.recv(1024)
18     if d:
19         buffer.append(d)
20     else:
21         break
22 data = b‘‘.join(buffer)
23 # 关闭连接:
24 s.close()
25
26 header, html = data.split(b‘\r\n\r\n‘, 1)
27 print(header.decode(‘utf-8‘))
28 # 把接收的数据写入文件:
29 with open(‘sina.html‘, ‘wb‘) as f:
30     f.write(html)

自定义客户端访问sina首页

参考资料：

1. http://www.cnblogs.com/linhaifeng/articles/6129246.html

2. http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001432004374523e495f640612f4b08975398796939ec3c000

3. http://baike.baidu.com/item/socket/281150