客户端/服务器架构
服务器是一系列硬件或软件，为一个或多个客户端（服务的用户）提供所需的“服务”。它存在的唯一目的就是等待客户端的请求，并响应它们（提供服务），然后等待更多请求。
客户端因特定的请求而联系服务器，并发送必要的数据，然后等待服务器的回应，最后完成请求或给出故障的原因。
客户端/服务器架构既可以应用于计算机硬件，也可以应用于软件。
硬件客户端/服务器架构
打印服务器、文件服务器
软件客户端/服务器架构
web服务器
数据库服务器
窗体服务器
客户端/服务器网络编程
在服务器响应客户端请求之前，首先会创建一个通信端点，它能够使服务器监听请求。一旦一个通信端点已经建立，监听服务器就可以进入无限循环中，等待客户端的连接并响应它们的请求。
客户端所需要做的只是创建它的单一通信端点，然后建立一个到服务器的连接。然后，客户端就可以发出请求，该请求包括任何必要的数据交换，一旦请求被服务器处理，且客户端收到结果或某种确认信息，此次通信就会被终止。
套接字：通信端点
套接字
在任何类型的通信开始之前，网络应用程序必须创建套接字，没有它将无法进行通信。
有两种类型的套接字：基于文件的和面向网络的。
基于文件的：
AF_UNIX，它代表地址家族：UNIX。
基于网络的：
AF_INET，它代表地址家族：因特网，使用最广泛。
AF_INET6，用于第6版因特网协议（IPv6）寻址。
AF_NETLINK，无连接的套接字。
AF_TIPC，支持TIPC，TIPC（进程间通信协议）允许计算机及群之中的及其相互通信。
python只支持AF_UNIX、AF_NETLINK、AF_TIPC、AF_INET家族。
套接字地址：主机-端口对
一个网络地址由主机名和端口号对组成，有效的端口号范围 0-65535。
面向连接的套接字 TCP
在进行通信之前必须先建立一个连接，这种类型的通信也成为虚拟电路或者流套接字。
实现这种连接类型的主要协议是传输控制协议（TCP）。
为了创建TCP套接字，必须使用SOCK_STREAM作为套接字类型。
无连接的套接字 UDP
数据报类型的套接字，它是一种无连接的套接字，在通信开始之前并不需要建立连接。
实现这种连接类型的主要协议是用户数据报协议（UDP）。
为了创建UDP套接字，必须使用SOCK_DGRAM作为套接字类型。
python中的网络编程 socket模块
socket()函数，用于创建套接字对象。
socket()模块函数
创建套接字：
socket(socket_family, socket_type, protocol=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)
*使用from socket import ：
tcpSock = socket(AF_INET, SOCK_STREAM)
udpSock = socket(AF_INET, SOCK_DGRAM)
套接字对象内置方法
| 名称 | 描述 |
|---|---|
| 服务器端套接字函数 | |
| s.bind() | 绑定地址（主机，端口号对）到套接字 |
| s.listen() | 设置并启动 TCP 监听器 |
| s.accept() | 被动接受 TCP 客户端的连接，一直等待直到连接到达（阻塞） |
| 客户端套接字函数 | |
| s.connect() | 主动初始化 TCP 服务器连接 |
| s.connect_ex() | connect()函数的扩展版本，此时会以错误码的形式返回问题，而不是抛出一个异常 |
| 普通的套接字函数 | |
| s.recv() | 接收 TCP 消息 |
| s.recv_into() | 接收 TCP 消息到指定的缓冲区 |
| s.send() | 发送 TCP 消息 |
| s.sendall() | 完整地发送 TCP 消息 |
| s.recvfrom() | 接收 UDP 消息 |
| s.recvfrom_into() | 接收 UDP 消息到指定的缓冲区 |
| s.sendto() | 发送 UDP 消息 |
| s.getpeername() | 连接到套接字（TCP）的远程地址 |
| s.getsockname() | 当前套接字的地址 |
| s.getsockopt() | 返回给定套接字选项的值 |
| s.setsockopt() | 设置给定套接字选项的值 |
| s.shutdown() | 关闭连接 |
| s.close() | 关闭套接字 |
| s.detach() | 在未关闭文件描述符的情况下关闭套接字，返回文件描述符 |
| s.ioctl() | 控制套接字的模式 |
| 面向阻塞的套接字方法 | |
| s.setblocking() | 设置套接字的阻塞与非阻塞模式 |
| s.settimeout() | 设置阻塞套接字操作的超时时间 |
| s.gettimeout() | 得到阻塞套接字操作的超时时间 |
| 面向文件的套接字的函数 | |
| s.fileno() | 套接字的文件描述符 |
| s.makefile() | 创建一个与该套接字关联的文件对象 |
| 数据属性 | |
| s.family() | 套接字家族 |
| s.type | 套接字类型 |
| s.proto | 套接字协议 |
创建TCP服务器
伪代码：
ss = socket() # 创建服务器套接字
ss.bind() # 套接字与地址绑定
ss.listen() # 监听连接
inf_loop: # 服务器无限循环
cs = ss.accept() # 接受客户端连接
comm_loop: # 通信循环
cs.recv()/cs.send() # 对话（接收/发送）
cs.close() # 关闭客户端套接字
ss.close() # 关闭服务器套接字（可选）
TCP时间戳服务器：这个脚本创建一个TCP服务器，它接收来自客户端的消息，然后将消息加上时间戳前缀并发送回客户端。
from socket import *
from time import ctime
HOST = '' # 变量是空白的，表示它可以使用任何可用的地址
PORT = 21567 # 选择一个随机的端口号
BUFSIZ = 1024 # 对于该应用程序，将缓冲区大小设置为1KB
ADDR = (HOST, PORT) # 套接字地址，主机-端口对
tcpSerSock = socket(AF_INET, SOCK_STREAM) # 分配了TCP服务器套接字
tcpSerSock.bind(ADDR) # 将套接字绑定到服务器地址，下一行开启TCP监听器的调用
tcpSerSock.listen(5) # listen()方法的参数实在连接被转接或拒绝之前，接入连接请求的最大数
while True: # 进入服务器的无限循环之中，被动的等待客户端的连接
print 'waiting for connection...'
tcpCliSock, addr = tcpSerSock.accept() # 当一个连接请求出现时，我们进入对话循环中
print '...connected from:', addr
while True: # 在该循环中我们等待客户端发送的消息
data = tcpCliSock.recv(BUFSIZ)
if not data: # 如果消息是空白的，这意味着客户端已经退出，此时将跳出对话循环，然后等待另一个客户端连接
break
tcpCliSock.send('[%s] %s' % (ctime(), data)) # 如果得到客户端发送的消息，就将其格式化并返回相同的数据，但是会在这些数据中加上当前时间戳的前缀。
tcpCliSock.close()
tcpSerSock.close() # 永远不会执行
创建TCP客户端
伪代码：
cs = socket() # 创建客户端套接字
cs.connect() # 尝试连接服务器
ss.listen() # 通信循环
comm_loop: # 服务器无限循环
cs.recv()/cs.send() # 对话（接收/发送）
cs.close() # 关闭客户端套接字
TCP时间戳客户端：这个脚本创建一个TCP客户端，它提示用户输入发送到服务器端的消息，并接受从服务器端返回的添加了时间戳前缀的相同消息，然后将结果展示给用户。
from socket import *
HOST = 'localhost' # 指定服务器的主机名
PORT = 21567 # 指定服务器的端口号，端口号PORT应该与你为服务器设置的完全相同
BUFSIZ = 1024 # 对于该应用程序，将缓冲区大小设置为1KB
ADDR = (HOST, PORT) # 套接字地址，主机-端口对
tcpCliSock = socket(AF_INET, SOCK_STREAM) # 分配了TCP客户端套接字
tcpCliSock.connect(ADDR) # 主动调用并连接到服务器
while True: # 并不会永远进行下去
data = raw_input('> ') # 第一种条件：用户没有输入
if not data:
break
tcpCliSock.send(data)
data = tcpCliSock.recv(BUFSIZ) # 服务器终止且对recv()方法的调用失败
if not data:
break
print data
tcpCliSock.close()
创建UDP服务器
伪代码：
ss = socket() # 创建服务器套接字
ss.bind() # 绑定服务器套接字
inf_loop: # 服务器无限循环
cs = ss.recvfrom()/ss.sendto() # 关闭（接收/发送）
ss.close() # 关闭服务器套接字（可选）
UDP时间戳服务器：这个脚本创建一个UDP服务器，它接受客户端发来的消息，并将加了时间戳前缀的该消息返回给客户端。
from socket import *
from time import ctime
HOST = '' # 变量是空白的，表示它可以使用任何可用的地址
PORT = 21567 # 选择一个随机的端口号
BUFSIZ = 1024 # 对于该应用程序，将缓冲区大小设置为1KB
ADDR = (HOST, PORT) # 套接字地址，主机-端口对
udpSerSock = socket(AF_INET, SOCK_DGRAM) # 分配了UDP服务器套接字
udpSerSock.bind(ADDR) # 将套接字绑定到服务器地址
while True: # 进入服务器的无限循环之中，被动的等待客户端的连接
print 'waiting for message...'
data, addr = udpSerSock.recvfrom(BUFSIZ) # 当一条消息到达时，我们就处理它，并将其发送回客户端，然后等待另一条消息
udpSerSock.sendto('[%s] %s' % (ctime(), data), addr)
print '...received from and returned to:', addr
udpSerSock.close() # 永远不会执行
创建UDP客户端
伪代码：
cs = socket() # 创建客户端套接字
comm_loop: # 通信循环
cs.sendto()/cs.recvfrom() # 对话（接收/发送）
cs.close() # 关闭客户端套接字
UDP时间戳客户端：这个脚本创建一个UDP客户端，它提示用户输入发送给服务器的消息，并接收服务器加了时间戳前缀的消息，然后将它们显示给用户。
from socket import *
HOST = 'localhost' # 指定服务器的主机名
PORT = 21567 # 指定服务器的端口号，端口号PORT应该与你为服务器设置的完全相同
BUFSIZ = 1024 # 对于该应用程序，将缓冲区大小设置为1KB
ADDR = (HOST, PORT) # 套接字地址，主机-端口对
udpCliSock = socket(AF_INET, SOCK_DGRAM) # 分配了UDP客户端套接字
while True: # 并不会永远进行下去
data = raw_input('> ') # 第一种条件：用户没有输入
if not data:
break
udpCliSock.sendto(data, ADDR) # 简单的发送一条消息并等待副武器的回复
data, ADDR = udpCliSock.recvfrom(BUFSIZ) # 服务器终止且对recvfrom()方法的调用失败
if not data:
break
print data
udpCliSock.close()
socket模块属性
| 属性 | 描述 |
|---|---|
| 数据属性 | |
| AF_UNIX, AF_INET, AF_INET6、AF_NETLINK、AF_TIPC | Python 支持的套接字地址家族 |
| SO_STREAM, SO_DGRAM | 套接字类型 (TCP = 流, UDP = 数据报) |
| has_ipv6 | 表示是否支持 IPv6 的布尔标记 |
| 异常 | |
| error | 套接字相关错误 |
| herror | 主机和地址相关的错误 |
| gaierror | 地址相关的错误 |
| timeout | 超时 |
| 函数 | |
| socket() | 用指定的地址家族，套接字类型和协议类型（可选）创建一个套接字对象 |
| socketpair() | 用指定的地址家族，套接字类型和协议类型（可选）创建一对套接字对象 |
| create_connection() | 常规函数，它接收一个地址（主机名，端口号）对，返回套接字对象 |
| fromfd() | 用一个已经打开的文件描述符创建一个套接字对象 |
| ssl() | 通过套接字启动一个安全套接字层(SSL)连接；不做证书验证。 |
| getaddrinfo() | 获取一个五元组序列形式的地址消息 |
| getnameinfo() | 给定一个套接字地址，返回（主机名，端口号）二元组 |
| getfqdn() | 返回完整的域名 |
| gethostname() | 返回当前主机名 |
| gethostbyname() | 将一个主机名映射到它的IP地址 |
| gethostbyname_ex() | gethostbyname()的扩展版本，返回主机名，主机所有的别名和 IP 地址列表。 |
| gethostbyaddr() | 由 IP 地址得到 DNS 信息，返回一个类似 gethostbyname_ex() 的 3 元组。 |
| getprotobyname() | 将一个协议名（如‘tcp’）映射到一个数字 |
| getservbyname()/getservbyport() | 将一个服务名映射到一个端口号，或者反过来；对于任何一个函数来说，协议名都是可选的 |
| ntohl()/ntohs() | 将来自网络的整数转换为主机字节顺序 |
| htonl()/htons() | 将来自主机的整数转换为网络字节顺序 |
| inet_aton()/inet_ntoa() | 将IP地址八进制字符串转换为32位的包格式，或者反过来（仅用于IPv4地址） |
| inet_pton()/net_ntop() | 将IP地址字符串转换成打包的二进制格式，或者反过来（同时适用于IPv4和IPv6地址） |
| getdefaulttimeout()/setdefaulttimeout() | 以秒（浮点数）为单位返回默认套接字超时时间；以秒（浮点数）为单位设置默认套接字超时时间 |
SocketServer模块
SocketServer模块
| 类 | 描述 |
|---|---|
| BaseServer | 包含服务器的核心功能与混合(mix-in)类的钩子功能；仅用于推到，这样不会创建这个类的实例；可以用TCPServer或UDPServer创建类的实例 |
| TCPServer/ UDPServer | 基础的网络同步 TCP/UDP 服务器 |
| UnixStreamServer/ UnixDatagramServer | 基于文件的基础同步 TCP/UDP 服务器 |
| ForkingMixIn/ThreadingMixIn | 核心派出或线程功能；只用作mix-in类与一个服务器类配合实现一些异步性；不能直接实例化这个类 |
| ForkingTCPServer/ ForkingUDPServer | ForkingMixIn 和 TCPServer/UDPServer 的组合 |
| ThreadingTCPServer/ ThreadingUDPServer | ThreadingMixIn 和 TCPServer/UDPServer 的组合 |
| BaseRequestHandler | 包含处理服务请求的核心功能；仅仅用于推导，这样无法创建这个类的实例；可以使用 StreamRequestHandler 或 DatagramRequestHandler创建类的实例 |
| StreamRequestHandler/ DatagramRequestHandler | 实现TCP/UDP 服务器的服务处理器 |
创建SocketServerTCP 服务器
SocketServer 时间戳服务器：通过使用 SocketServer 类、TCPServer 和 StreamRequestHandler ，创建一个时间戳 TCP 服务器。
from SocketServer import (TCPServer as TCP, StreamRequestHandler as SRH)
from time import ctime
HOST = '' # 变量是空白的，表示它可以使用任何可用的地址
PORT = 21567 # 选择一个随机的端口号
ADDR = (HOST, PORT) # 套接字地址，主机-端口对
class MyRequestHandler(SRH): # 得到了请求处理程序MyRequestHandler，作为SocketServer中StreamRequestHandler的一个子类
def handle(self): # 重写handle方法，当街收到一个来自客户端的消息时，就调用它
print '...connected from:', self.client_address
self.wfile.write('[%s] %s' % (ctime(), self.rfile.readline())) # 使用readline()来获取客户端消息，并利用write()将字符串发送回客户端
tcpServ = TCP(ADDR, MyRequestHandler) # 用给定的主机信息和请求处理类创建了TCP服务器
print 'waiting for connection...'
tcpServ.serve_forever() # 无限循环的等待并服务于客户端请求
创建SocketServerTCP 客户端
SocketServer 时间戳客户端：它知道如何与类似文件的SocketServer类StreamRequest Handler 对象通信。
from socket import *
HOST = 'localhost' # 指定服务器的主机名
PORT = 21567 # 指定服务器的端口号，端口号PORT应该与你为服务器设置的完全相同
BUFSIZ = 1024 # 对于该应用程序，将缓冲区大小设置为1KB
ADDR = (HOST, PORT) # 套接字地址，主机-端口对
while True: # 并不会永远进行下去
tcpCliSock = socket(AF_INET, SOCK_STREAM) # 分配了TCP客户端套接字
tcpCliSock.connect(ADDR) # 主动调用并连接到服务器
data = raw_input('> ') # 第一种条件：用户没有输入
if not data:
break
tcpCliSock.send('%s\r\n' % data) # 因为这里使用的处理程序类对待套接字通信就像文件一样，所以必须发送行终止符
data = tcpCliSock.recv(BUFSIZ) # 服务器终止且对recv()方法的调用失败
if not data:
break
print data.strip() # 当得到从服务器返回的消息时，用strip()函数对其进行处理并使用print声明自动提供的换行符
tcpCliSock.close() # SocketServer请求处理程序的默认行为是接受连接、获取请求，然后关闭连接
Twisted 框架介绍
Twisted 是一个完整的事件驱动的网络框架。利用它既能使用也能开发完整的异步网络应用程序和协议。
创建 Twisted Reactor TCP 服务器
Twisted Reactor 时间戳 TCP 服务器：这是一个使用 Twisted Internet 类的时间戳 TCP 服务器。
from twisted.internet import protocol, reactor
from time import ctime
PORT = 21567 # 设置常用端口号
class TSServProtocol(protocol.Protocol): # 获得protocol类并为时间戳服务器调用TSServProtocol
def connectionMade(self): # 重写 connectionMade，当一个客户端连接到服务器时就会执行
clnt = self.clnt = self.transport.getPeer().host # 获取主机信息
print '...connected from:', clnt
def dataReceived(self, data): # 重写 dataReceived，当服务器接收到客户端通过网络发送的一些数据时就会调用
self.transport.write('[%s] %s' % (ctime(), data))
factory = protocol.Factory() # 创建一个协议工厂，因为每次得到一个接入连接时，都能制造协议的一个实例
factory.protocol = TSServProtocol
print 'waiting for connection...' # reactor中安装一个TCP监听器，以此检查服务请求，当它接收到一个请求时，就会创建一个TSServProtocol实例来处理那个客户端的事务
reactor.listenTCP(PORT, factory) # reactor作为该方法的一个参数在数据中传输，能在无须自己提取它的情况下访问它
reactor.run()
创建 Twisted Reactor TCP 客户端
Twisted Reactor Timestamp TCP 客户端：用 Twisted 重写我们已经熟悉的时间戳 TCP 客户端。
from twisted.internet import protocol, reactor
from time import ctime
PORT = 21567 # 设置常用端口号
class TSServProtocol(protocol.Protocol): # 获得protocol类并为时间戳服务器调用TSServProtocol
def connectionMade(self): # 重写 connectionMade，当一个客户端连接到服务器时就会执行
clnt = self.clnt = self.transport.getPeer().host # 获取主机信息
print '...connected from:', clnt
def dataReceived(self, data): # 重写 dataReceived，当服务器接收到客户端通过网络发送的一些数据时就会调用
self.transport.write('[%s] %s' % (ctime(), data))
factory = protocol.Factory() # 创建一个协议工厂，因为每次得到一个接入连接时，都能制造协议的一个实例
factory.protocol = TSServProtocol
print 'waiting for connection...' # reactor中安装一个TCP监听器，以此检查服务请求，当它接收到一个请求时，就会创建一个TSServProtocol实例来处理那个客户端的事务
reactor.listenTCP(PORT, factory) # reactor作为该方法的一个参数在数据中传输，能在无须自己提取它的情况下访问它
reactor.run()
