《python核心编程》读书笔记 第二章 网络编程

一、服务器/客户端的概念

想象客户端/服务器架构如何工作的一个方法就是,在你的脑海中创建一个画面,那就是一个银行出纳员,他既不吃不睡,也不休息,服务一个又一个的排队客户,似乎永远不会结束。这个队列可能很长,也可能空无一人,但在任何给定的某个时刻,都可能会出现一个客户。当然,在几年前这样的出纳员完全是一种幻想,但是现在的自动取款机(ATM)似乎比较接近这种模型。

出纳员就是一个运行在无限循环中的服务器,每个客户就是一个客户端。

二、服务器/客户端网络编程

在服务器响应客户端请求之前,必须进行一些初步的设置来为之后的工作做准备,首先会创建一个通信端点,它能够使服务器监听请求——这个服务端点可以类比于电话号码和设备安装成功而且接线员到达,此时监听服务器可以进入无限循环中,等待客户端的连接并响应它们的请求。

客户端要做的事情更简单,就是创建它的单一通信端点,然后建立一个到服务器的连接,发出请求,和服务器进行通信。

三、套接字(socket)

套接字就体现了上文的“通信端点”,类似于打电话时的电话插口。服务器就像一个大插排,包含很多插座,客户端就是像一个插头,每一个线程代表一条电线,客户端将电线的插头插到服务器插排上对应的插座上,就可以开始通信了。它是一种机制,凭借这种机制,客户/服务器系统的开发工作既可以在本地单机上进行,也可以跨网络进行。

《python核心编程》读书笔记 第二章 网络编程_第1张图片

 

为了确定一个套接字,我们需要知道通信的目的IP地址、使用的传输层协议(TCP或UDP)和使用的端口号。IP地址和端口号确定的是通信的对象,而传输层协议分为两种。一种是面向连接的套接字(传输控制协议,简称TCP,使用SOCK_STREAM作为套接字类型),在进行TCP通信之前必须建立一个连接;一种是无连接的套接字(用户数据报协议,简称UDP,使用SOCK_DGRAM作为套接字类型),这意味着通信开始之前不需要建立连接,可能存在重复和遗漏问题,但是成本低廉。由于这些套接字都是用互联网协议(IP)来寻找网络中的主机,因此又分别被称为TCP/IP和UDP/IP协议。

四、python中的网络编程

这里主要使用socket模块,在这个模块中可以找到socket函数,该函数主要用于创建套接字对象,套接字也有自己的方法集,这些方法可以实现基于套接字的网络通信。

(1)TCP

创建TCP服务器的伪代码:

《python核心编程》读书笔记 第二章 网络编程_第2张图片

python3代码如下:

from socket import *
from time import ctime

Host=''             #对bind方法的标识,表示它可以使用任何可用的地址
Port=21567          #可以使用0~65535中间任何一个未被占用的端口号
Bufsize=1024        #缓冲区
Addr=(Host,Port)    #在连接被转接或拒绝之前,传入连接请求的最大数。
 
tcpSersock=socket(AF_INET,SOCK_STREAM)  #tcp套接字。如果要走ipv6仅仅需要将地址家族中的AF_INET(IPv4)修改成AF_INET6(IPv6)
tcpSersock.bind(Addr)                   #将套接字绑定到服务器
tcpSersock.listen(5)                    #开启监听

while True:
    print('waiting for connection')
    tcpclisock,addr=tcpSersock.accept() #accept的实现是堵塞的,也就是说除非收到数据,不然它会一直停在这里
    print('--- connect from:',addr)
    while True:                         #如果消息是空白的,这意味着客户端已经退出,所以此时我们将跳出对话循环,关闭当前客户端连接,然后等待另一个客户端连接。
                                        #如果确实得到了客户端发送的消息,就将其格式化并返回相同的数据,但是会在这些数据中加上当前时间戳的前缀。
        data=tcpclisock.recv(Bufsize)
        if not data:
            break
        tcpclisock.send(b'[%s] %s'%(bytes(ctime(),'utf-8'),data))
    tcpclisock.close()
tcpSersock.close()  #最后一行永远不会执行,它只是用来提醒应当考虑一个更加优雅的退出方式,比如给代码加一个异常处理

创建客户端的伪代码:

《python核心编程》读书笔记 第二章 网络编程_第3张图片

python3代码:

from socket import *

Host='127.0.0.1'    #也可以使用"localhost"这个字符串,如果你的服务器运行在另一台主机上,那么需要进行相应修改)
                    #端口号PORT 应该与你为服务器设置的完全相同(否则,将无法进行通信)。
                    #若使用ipv6则本机地址变为"::1"
Port=21567
Bufsize=1024
Addr=(Host,Port)

tcpclisock=socket(AF_INET,SOCK_STREAM)
tcpclisock.connect(Addr)

while True:
    data=input('> ')
    if not data:                    #若用户没有输入
        break
    tcpclisock.send(data.encode()) 
    data=tcpclisock.recv(Bufsize)   #或服务器终止且对recv的调用失败,则跳出,否则,客户端接收到加了时间戳的字符串,并显示在屏幕上
    if not data:
        break
    print(data.decode('utf-8'))
tcpclisock.close()

下面我们来看运行结果:

客户端

《python核心编程》读书笔记 第二章 网络编程_第4张图片

服务器:

服务器这里记录的是连接而非会话,比如如果我们用空输入结束客户端,再重新开始,那么

客户端:

《python核心编程》读书笔记 第二章 网络编程_第5张图片

服务器:

这里把连接情况打印出来只是为了说明TCP协议中有连接这一步,把会话信息也打印出来是可以的,但没必要。

(2)UDP

UDP 服务器不需要TCP 服务器那么多的设置,因为它们不是面向连接的。除了等待传入的连接之外,几乎不需要做其他工作。伪代码:

《python核心编程》读书笔记 第二章 网络编程_第6张图片

除了普通的创建套接字并将其绑定到本地地址(主机名/端口号对)外,并没有额外的工作。无限循环包含接收客户端消息、打上时间戳并返回消息,然后回到等待另一条消息的状态。再一次,close()调用是可选的,并且由于无限循环的缘故,它并不会被调用,但它提醒我们,它应该是我们已经提及的优雅或智能退出方案的一部分。
UDP 和TCP 服务器之间的另一个显著差异是,因为数据报套接字是无连接的,所以就没有为了成功通信而使一个客户端连接到一个独立的套接字“转换”的操作。这些服务器仅仅接受消息并有可能回复数据。

from socket import *
from time import ctime

Host=''
Port=21567
Bufsize=1024
Addr=(Host,Port)

udpsersock=socket(AF_INET,SOCK_DGRAM)
udpsersock.bind(Addr) #因为UDP 是无连接的,所以这里没有调用“监听传入的连接”。

while True:
    print('waiting for message ') #被动地等待信息并处理
    data,addr=udpsersock.recvfrom(Bufsize)
    print('from:',addr)
    udpsersock.sendto(b'[%s] %s'%(bytes(ctime(),'utf-8'),data),addr)

udpsersock.close()

客户端:

《python核心编程》读书笔记 第二章 网络编程_第7张图片

UDP 客户端循环工作方式几乎和TCP 客户端完全一样。唯一的区别是,事先不需要建立与UDP 服务器的连接,只是简单地发送一条消息并等待服务器的回复。在时间戳字符串返回后,将其显示到屏幕上,然后等待更多的消息。最后,当输入结束时,跳出循环并关闭套接字。

from socket import *

Host='127.0.0.1'
Port=21567
Bufsize=1024
Addr=(Host,Port)

udpserSock=socket(AF_INET,SOCK_DGRAM)
while True:
    data=input('> ')
    if not data:
        break
    udpserSock.sendto(data.encode(),Addr)
    data,addr=udpserSock.recvfrom(Bufsize)
    if not data:
        break
print(data.decode())

代码本身没什么好说的,运行结果如下。

客户端:

《python核心编程》读书笔记 第二章 网络编程_第8张图片

服务器:

这里我们就只能waiting for message了,因为没有connection给我们waiting。

另一个问题是,在运行代码时尝试了开一个服务器——多个客户端这样的情况,对于UDP来说是没有任何问题的。

但是对于TCP协议来说,后一个打开的客户端并不能建立连接。除非前一个连接已经断开。考虑我们的代码是一个简单的单进程连接,这更说明了TCP和UDP的不同之处。

 

五、SocketServer模块。

SocketServer 是标准库中的一个高级模块(Python 3.x 中重命名为socketserver),它的目标是简化很多样板代码,它们是创建网络客户端和服务器所必需的代码。除了为你隐藏了实现细节之外,另一个不同之处是,我们现在使用类来编写应用程序。因为以面向对象的方式处理事务有助于组织数据,以及逻辑性地将功能放在正确的地方。你还会注意到,应用程序现在是事件驱动的,这意味着只有在系统中的事件发生时,它们才会工作。事件包括消息的发送和接收。事实上,你会看到类定义只包括一个用来接收客户端消息的事件处理程序。所有其他的功能都来自使用的SocketServer 类。

from socketserver import (TCPServer as TCP,StreamRequestHandler as SRH)
from time import ctime

Host=''
Port=21567
Addr=(Host,Port)

class MyRequesHandler(SRH):
    def handle(self):  #我们得到了请求处理程序MyRequestHandler,作为SocketServer中StreamRequestHandler 的一个子类,并重写了它的handle()方法,该方法在基类Request 中默认情况下没有任何行为。
                       #当接收到一个来自客户端的消息时,它就会调用handle()方法。而StreamRequestHandler类将输入和输出套接字看作类似文件的对象,因此我们将使用readline()来获取客户端消息,并利用write()将字符串发送回客户端
        print('... connected from:',self.client_address)
        self.wfile.write(('[%s] %s'%(ctime(),self.rfile.readline().decode())).encode())

tcpServ=TCP(Addr,MyRequesHandler)
print('waiting for connect')
tcpServ.serve_forever()
from socket import *

Host='127.0.0.1'
Port=21567
Bufsize=1024
Addr=(Host,Port)



while True:
    tcpclisock=socket(AF_INET,SOCK_STREAM) #SocketServer 请求处理程序的默认行为是接受连接、获取请求,然后关闭连接。由于这个原因,我们不能在应用程序整个执行过程中都保持连接,因此每次向服务器发送消息时,都需要创建一个新的套接字。这种行为使得TCP 服务器更像是一个UDP 服务器
    tcpclisock.connect(Addr)    
    data=input('> ')
    if not data:
        break
    tcpclisock.send(('%s \r\n'%data).encode())
    data=tcpclisock.recv(Bufsize)
    if not data:
        break   
    print(data.decode())
tcpclisock.close()

六、Twisted 框架介绍

与 SocketServer 类似,Twisted 的大部分功能都存在于它的类中。特别是对于该示例,我们将使用Twisted 因特网组件中的reactor 和protocol 子包中的类。

安装Twisted框架稍微费了一点事,主要是安装版本不对了,直接在cmd里面用pip是会安装失败的,需要手动下载执行,只要下载whl文件的时候注意对上python版本和系统位数即可。cpxx对应python版本号,amd64对应64位的python(注意是64位的python,不是64位的电脑~~)下载地址在这里https://www.lfd.uci.edu/~gohlke/pythonlibs/

import os
from twisted.internet import protocol, reactor
from time import ctime

PORT = 21568

class TSServProtocol(protocol.Protocol):
    #我们获得protocol 类并为时间戳服务器调用TSServProtocol。然后重写了connectionMade()和dataReceived()方法,当一个客户端连接到服务器时就会执行connectionMade()方法,而当服务器接收到客户端通过网络发送的一些数据时就会调用dataReceived()方法。reactor 会作为该方法的一个参数在数据中传输,这样就能在无须自己提取它的情况下访问它。
    ##此外,传输实例对象解决了如何与客户端通信的问题。你可以看到我们如何在connectionMade()中使用它来获取主机信息,这些是关于与我们进行连接的客户端的信息,以及如何在dataReceived()中将数据返回给客户端。
    def connectionMade(self):
        clnt = self.clnt = self.transport.getPeer().host
        print('...connected from:', clnt)

    def dataReceived(self, data):
        self.transport.write(bytes('%s current time is : [%s] %s' %(os.listdir
                                   (),ctime(), data.decode("utf-8")),"utf-8"))
#在服务器代码的最后部分中,创建了一个协议工厂。它之所以被称为工厂,是因为每次得到一个接入连接时,都能“制造”协议的一个实例。然后在reactor 中安装一个TCP 监听器,以此检查服务请求。当它接收到一个请求时,就会创建一个TSServProtocol 实例来处理那个客户端的事务。
factory = protocol.Factory()
factory.protocol = TSServProtocol
print('waiting for connection...')
reactor.listenTCP(PORT, factory)
reactor.run()
from twisted.internet import protocol, reactor

HOST = '127.0.0.1'
PORT = 21568

#类似于服务器,我们通过重写connectionMade()和dataReceived()方法来扩展Protocol,并且这两者都会以与服务器相同的原因来执行。另外,还添加了自己的方法sendData(),当需要发送数据时就会调用它。
#以上行为会在一个循环中继续,直到当提示输入时我们不输入任何内容来关闭连接。此时,并非调用传输对象的write()方法发送另一个消息到服务器,而是执行loseConnection()来关闭套接字。当发生这种情况时,将调用工厂的clientConnectionLost()方法以及停止reactor,结束脚本执行。此外,如果因为某些其他的原因而导致系统调用了clientConnectionFailed(),那么也会停止reactor。
class TSClntProtocol(protocol.Protocol):
    def sendData(self):
        data = (input('> ')).encode("utf-8")
        if data:
            print("...sending %s ..."%data.decode("utf-8"))
            self.transport.write(data)
        else:
            self.transport.loseConnection()
            
    def connectionMade(self):
        self.sendData()

    def dataReceived(self, data):
        print(data.decode("utf-8"))
        self.sendData()

class TSClntFactory(protocol.ClientFactory):
    protocol = TSClntProtocol
    clientConnectionLost = clientConnectionFailed = \
        lambda self, connector, reason: reactor.stop()

#在脚本的最后部分创建了一个客户端工厂,创建了一个到服务器的连接并运行reactor。
#注意,这里实例化了客户端工厂,而不是将其传递给reactor,正如我们在服务器上所做的那样。这是因为我们不是服务器,需要等待客户端与我们通信,并且它的工厂为每一次连接都创建一个新的协议对象。因为我们是一个客户端,所以创建单个连接到服务器的协议对象,而服务器的工厂则创建一个来与我们通信。
reactor.connectTCP(HOST, PORT, TSClntFactory())
reactor.run()

注:第五六节的注释是直接复制原文的,因为我也没看太懂,用到的时候再慢慢看吧

 

 

 

 

你可能感兴趣的:(《python核心编程》读书笔记 第二章 网络编程)