服务器是一系列硬件或软件,为一个或多个客户端(服务的用户)提供所需的“服务”。它存在的唯一目的就是等待客户端的请求,并响应它们(提供服务),然后等待更多请求。
客户端因特定的请求而联系服务器,并发送必要的数据,然后等待服务器的回应,最后完成请求或给出故障的原因。
客户端/服务器架构既可以应用于计算机硬件,也可以应用于软件。
打印服务器、文件服务器
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套接字,必须使用SOCK_STREAM作为套接字类型。
数据报类型的套接字,它是一种无连接的套接字,在通信开始之前并不需要建立连接。
实现这种连接类型的主要协议是用户数据报协议(UDP)。
为了创建UDP套接字,必须使用SOCK_DGRAM作为套接字类型。
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 | 套接字协议 |
伪代码:
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() # 永远不会执行
伪代码:
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()
伪代码:
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() # 永远不会执行
伪代码:
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()
属性 | 描述 |
---|---|
数据属性 | |
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() | 以秒(浮点数)为单位返回默认套接字超时时间;以秒(浮点数)为单位设置默认套接字超时时间 |
类 | 描述 |
---|---|
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 服务器的服务处理器 |
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() # 无限循环的等待并服务于客户端请求
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 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 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()