Python核心编程——第2章网络编程笔记

太过爱你忘了你带给我的痛 2022-05-21 04:14 150阅读 0赞

*  第2章 网络编程
    
     *  2.1 Python 中的网络编程
        
         *  2.1.1 socket()模块函数
         *  2.1.2 创建 TCP 服务器
            
             *  TCP 时间戳服务器
         *  2.1.3 创建TCP客户端
            
             *  TCP 时间戳客户端
             *  IPV6 TCP 时间戳客户端
         *  2.1.4 创建 UDP 服务器
            
             *  UDP 时间戳服务器
         *  2.1.5 创建 UDP 客户端
            
             *  UDP 时间戳客户端
             *  socket 模块属性
     *  2.2 \*SocketServer 模块
        
         *  2.2.1 创建 SocketServer TCP 服务器
            
             *  SocketServer 时间戳 TCP 服务器
         *  2.2.2 创建 SocketServer TCP 客户端
            
             *  SocketServer 时间戳 TCP 客户端
     *  2.3 \*Twisted 框架介绍
        
         *  2.3.1 创建 Twisted Reactor TCP 服务器
            
             *  Twisted Reactor 时间戳 TCP 服务器
         *  2.3.2 创建 Twisted Reactor TCP 客户端
            
             *  Twisted Reactor 时间戳 TCP 客户端

# 第2章 网络编程 #

## 2.1 Python 中的网络编程 ##

### 2.1.1 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 套接字，可以用下面的方式调用 socket.socket()。

tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

同样，为了创建 UDP/IP 套接字，需要执行以下语句。

udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

因为有很多 socket 模块属性，所以此时使用“from module import *”这种导入方式可以接受，不过这只是其中的一个例外。如果使用“from socket import* ”，那么我们就把 socket属性引入到了命名空间中。虽然这看起来有些麻烦，但是通过这种方式将能够大大缩短代码，正如下面所示。

tcpSock = socket(AF_INET, SOCK_STREAM)

一旦有了一个套接字对象，那么使用套接字对象的方法将可以进行进一步的交互。

常见的套接字对象方法和属性

<table> 
 <thead> 
  <tr> 
   <th>名 称</th> 
   <th>描 述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>服务器套接字方法</strong></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>s.bind()</td> 
   <td>将地址（主机名、端口号对）绑定到套接字上</td> 
  </tr> 
  <tr> 
   <td>s.listen()</td> 
   <td>设置并启动 TCP 监听器</td> 
  </tr> 
  <tr> 
   <td>s.accept()</td> 
   <td>被动接受 TCP 客户端连接，一直等待直到连接到达（阻塞）</td> 
  </tr> 
  <tr> 
   <td><strong>客户端套接字方法</strong></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>s.connect()</td> 
   <td>主动发起 TCP 服务器连接</td> 
  </tr> 
  <tr> 
   <td>s.connect_ex()</td> 
   <td>connect()的扩展版本，此时会以错误码的形式返回问题，而不是抛出一个异常</td> 
  </tr> 
  <tr> 
   <td><strong>普通的套接字方法</strong></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>s.recv()</td> 
   <td>接收 TCP 消息</td> 
  </tr> 
  <tr> 
   <td>s.recv_into()</td> 
   <td>接收 TCP 消息到指定的缓冲区</td> 
  </tr> 
  <tr> 
   <td>s.send()</td> 
   <td>发送 TCP 消息</td> 
  </tr> 
  <tr> 
   <td>s.sendall()</td> 
   <td>完整地发送 TCP 消息</td> 
  </tr> 
  <tr> 
   <td>s.recvfrom()</td> 
   <td>接收 UDP 消息</td> 
  </tr> 
  <tr> 
   <td>s.recvfrom_into()</td> 
   <td>接收 UDP 消息到指定的缓冲区</td> 
  </tr> 
  <tr> 
   <td>s.sendto()</td> 
   <td>发送 UDP 消息</td> 
  </tr> 
  <tr> 
   <td>s.getpeername()</td> 
   <td>连接到套接字（TCP）的远程地址</td> 
  </tr> 
  <tr> 
   <td>s.getsockname()</td> 
   <td>当前套接字的地址</td> 
  </tr> 
  <tr> 
   <td>s.getsockopt()</td> 
   <td>返回给定套接字选项的值</td> 
  </tr> 
  <tr> 
   <td>s.setsockopt()</td> 
   <td>设置给定套接字选项的值</td> 
  </tr> 
  <tr> 
   <td>s.shutdown()</td> 
   <td>关闭连接</td> 
  </tr> 
  <tr> 
   <td>s.close()</td> 
   <td>关闭套接字</td> 
  </tr> 
  <tr> 
   <td>s.detach()</td> 
   <td>在未关闭文件描述符的情况下关闭套接字，返回文件描述符</td> 
  </tr> 
  <tr> 
   <td>s.ioctl()</td> 
   <td>控制套接字的模式（仅支持 Windows）</td> 
  </tr> 
  <tr> 
   <td><strong>面向阻塞的套接字方法</strong></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>s.setblocking()</td> 
   <td>设置套接字的阻塞或非阻塞模式</td> 
  </tr> 
  <tr> 
   <td>s.settimeout()</td> 
   <td>设置阻塞套接字操作的超时时间</td> 
  </tr> 
  <tr> 
   <td>s.gettimeout()</td> 
   <td>获取阻塞套接字操作的超时时间</td> 
  </tr> 
  <tr> 
   <td><strong>面向文件的套接字方法</strong></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>s.fileno()</td> 
   <td>套接字的文件描述符</td> 
  </tr> 
  <tr> 
   <td>s.makefile()</td> 
   <td>创建与套接字关联的文件对象</td> 
  </tr> 
  <tr> 
   <td><strong>数据属性</strong></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>s.family</td> 
   <td>套接字家族</td> 
  </tr> 
  <tr> 
   <td>s.type</td> 
   <td>套接字类型</td> 
  </tr> 
  <tr> 
   <td>s.proto</td> 
   <td>套接字协议</td> 
  </tr> 
 </tbody> 
</table>

### 2.1.2 创建 TCP 服务器 ###

首先，我们将展现创建通用 TCP 服务器的一般伪代码，然后对这些代码的含义进行一般性的描述。需要记住的是，这仅仅是设计服务器的一种方式。一旦熟悉了服务器设计，那么你将能够按照自己的要求修改下面的伪代码来操作服务器。

ss = socket() # 创建服务器套接字
    ss.bind()  # 套接字与地址绑定
    ss.listen()  # 监听连接
    inf_loop:  # 服务器无限循环
        cs = ss.accept()  # 接受客户端连接
        comm_loop:  # 通信循环
            cs.recv() / cs.send()  # 对话（接收/发送）
        cs.close()  # 关闭客户端套接字
    ss.close()  # 关闭服务器套接字#（可选）

所有套接字都是通过使用 socket.socket()函数来创建的。因为服务器需要占用一个端口并等待客户端的请求，所以它们必须绑定到一个本地地址。因为 TCP 是一种面向连接的通信系统，所以在 TCP 服务器开始操作之前，必须安装一些基础设施。特别地， TCP 服务器必须监听（传入）的连接。一旦这个安装过程完成后，服务器就可以开始它的无限循环。

调用 accept()函数之后，就开启了一个简单的（单线程）服务器，它会等待客户端的连接。默认情况下， accept()是阻塞的，这意味着执行将被暂停，直到一个连接到达。另外，套接字确实也支持非阻塞模式，可以参考文档或操作系统教材，以了解有关为什么以及如何使用非阻塞套接字的更多细节。

一旦服务器接受了一个连接，就会返回（利用 accept()）一个独立的客户端套接字，用来与即将到来的消息进行交换。使用新的客户端套接字类似于将客户的电话切换给客服代表。当一个客户电话最后接进来时，主要的总机接线员会接到这个电话，并使用另一条线路将这个电话转接给合适的人来处理客户的需求。

这将能够空出主线（原始服务器套接字），以便接线员可以继续等待新的电话（客户请求），而此时客户及其连接的客服代表能够进行他们自己的谈话。同样地，当一个传入的请求到达时，服务器会创建一个新的通信端口来直接与客户端进行通信，再次空出主要的端口，以使其能够接受新的客户端连接。

一旦创建了临时套接字，通信就可以开始，通过使用这个新的套接字，客户端与服务器就可以开始参与发送和接收的对话中，直到连接终止。当一方关闭连接或者向对方发送一个空字符串时，通常就会关闭连接。

在代码中，一个客户端连接关闭之后，服务器就会等待另一个客户端连接。最后一行代码是可选的，在这里关闭了服务器套接字。其实，这种情况永远也不会碰到，因为服务器应该在一个无限循环中运行。在示例中这行代码用来提醒读者，当为服务器实现一个智能的退出方案时，建议调用 close()方法。例如，当一个处理程序检测到一些外部条件时，服务器就应该关闭。在这些情况下，应该调用一个 close()方法。

#### TCP 时间戳服务器 ####

# TCP时间戳服务器
    from socket import *
    from time import ctime
    # 导入time.ctime()和 socket 模块的所有属性
    
    # HOST 变量是空白的，这是对 bind()方法的标识，表示它可以使用任何可用的地址
    HOST = ''
    # 选择了一个随机的端口号，并且该端口号似乎没有被使用或被系统保留
    PORT = 21567
    # 对于该应用程序，将缓冲区大小设置为 1KB。可以根据网络性能和程序需要改变这个容量
    BUFSIZ = 1024
    ADDR = (HOST, PORT)
    
    # 分配 TCP 服务器套接字
    tcpSerSock = socket(AF_INET, SOCK_STREAM)
    # 将套接字绑定到服务器地址
    tcpSerSock.bind(ADDR)
    # 连接被转接或拒绝之前，传入连接请求的最大数
    tcpSerSock.listen(5)
    
    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(bytes('[%s] %s' % (ctime(), data), 'utf-8'))
    
        tcpCliSock.close()
    #最后一行永远不会执行，它只是用来提醒，如果写了一个处理程序来考虑一个更加优雅的退出方式，那么应该调用 close()方法。
    tcpSerSock.close()

### 2.1.3 创建TCP客户端 ###

#### TCP 时间戳客户端 ####

# TCP 时间戳客户端
    from socket import *
    
    # 服务器的主机名
    HOST = '127.0.0.1'  # or 'localhost'
    # 服务器的端口号
    PORT = 21567
    # 缓冲区大小设置为 1KB
    BUFSIZ = 1024
    ADDR = (HOST, PORT)
    
    # 分配 TCP 客户端套接字
    tcpCliSock = socket(AF_INET, SOCK_STREAM)
    # 主动调用并连接到服务器
    tcpCliSock.connect(ADDR)
    
    while True:
        data = input('>')
        if not data:
            break
        tcpCliSock.send(bytes(data, 'utf-8'))
        data = tcpCliSock.recv(BUFSIZ)
        if not data:
            break
        print(data.decode('utf-8'))
    
    tcpCliSock.close()

#### IPV6 TCP 时间戳客户端 ####

# IPV6 TCP 时间戳客户端
    from socket import *
    
    # 服务器的主机名
    HOST = '::1'
    # 服务器的端口号
    PORT = 21567
    # 缓冲区大小设置为 1KB
    BUFSIZ = 1024
    ADDR = (HOST, PORT)
    
    # 分配 TCP 客户端套接字
    tcpCliSock = socket(AF_INET6, SOCK_STREAM)
    # 主动调用并连接到服务器
    tcpCliSock.connect(ADDR)
    
    while True:
        data = input('>')
        if not data:
            break
        tcpCliSock.send(bytes(data, 'utf-8'))
        data = tcpCliSock.recv(BUFSIZ)
        if not data:
            break
        print(data.decode('utf-8'))
    
    tcpCliSock.close()

### 2.1.4 创建 UDP 服务器 ###

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

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
    ADDR = (HOST, PORT)
    
    udpSerSock = socket(AF_INET, SOCK_DGRAM)
    udpSerSock.bind(ADDR)
    
    while True:
        print('waiting for message...')
        data, addr = udpSerSock.recvfrom(BUFSIZ)
        udpSerSock.sendto(bytes('[%s] %s' % (ctime(), data), 'utf-8'), addr)
        print('...received from and returned to:', addr)
    
    udpSerSock.close()

### 2.1.5 创建 UDP 客户端 ###

UDP 客户端的代码是最短的。它的伪代码如下所示。

cs = socket() # 创建客户端套接字
    comm_loop: # 通信循环
        cs.sendto()/cs.recvfrom() # 对话（发送/接收）
    cs.close() # 关闭客户端套接字

一旦创建了套接字对象，就进入了对话循环之中，在这里我们与服务器交换消息。最后，当通信结束时，就会关闭套接字。

#### UDP 时间戳客户端 ####

# UDP 时间戳客户端
    from socket import *
    
    # 服务器的主机名
    HOST = '127.0.0.1'  # or 'localhost'
    # 服务器的端口号
    PORT = 21567
    # 缓冲区大小设置为 1KB
    BUFSIZ = 1024
    ADDR = (HOST, PORT)
    
    # 分配 TCP 客户端套接字
    udpCliSock = socket(AF_INET, SOCK_DGRAM)
    
    while True:
        data = input('>')
        if not data:
            break
        udpCliSock.sendto(bytes(data, 'utf-8'), ADDR)
        data, ADDR = udpCliSock.recvfrom(BUFSIZ)
        if not data:
            break
        print(data.decode('utf-8'))
    
    udpCliSock.close()

#### socket 模块属性 ####

<table> 
 <thead> 
  <tr> 
   <th>属 性 名 称</th> 
   <th>描 述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>数据属性</strong></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>AF_UNIX、 AF_INET、 AF_INET6、AF_NETLINK、 AF_TIPC</td> 
   <td>Python 中支持的套接字地址家族</td> 
  </tr> 
  <tr> 
   <td>SO_STREAM、 SO_DGRAM</td> 
   <td>套接字类型（TCP=流， UDP=数据报）</td> 
  </tr> 
  <tr> 
   <td>has_ipv6</td> 
   <td>指示是否支持 IPv6 的布尔标记</td> 
  </tr> 
  <tr> 
   <td><strong>异常</strong></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>error</td> 
   <td>套接字相关错误</td> 
  </tr> 
  <tr> 
   <td>herror</td> 
   <td>主机和地址相关错误</td> 
  </tr> 
  <tr> 
   <td>gaierror</td> 
   <td>地址相关错误</td> 
  </tr> 
  <tr> 
   <td>timeout</td> 
   <td>超时时间</td> 
  </tr> 
  <tr> 
   <td><strong>函数</strong></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>socket()</td> 
   <td>以给定的地址家族、套接字类型和协议类型（可选）创建一个套接字对象</td> 
  </tr> 
  <tr> 
   <td>socketpair()</td> 
   <td>以给定的地址家族、套接字类型和协议类型（可选）创建一对套接字对象</td> 
  </tr> 
  <tr> 
   <td>create_connection()</td> 
   <td>常规函数，它接收一个地址（主机名，端口号）对，返回套接字对象</td> 
  </tr> 
  <tr> 
   <td>fromfd()</td> 
   <td>以一个打开的文件描述符创建一个套接字对象</td> 
  </tr> 
  <tr> 
   <td>ssl()</td> 
   <td>通过套接字启动一个安全套接字层连接；不执行证书验证</td> 
  </tr> 
  <tr> 
   <td>getaddrinfo()</td> 
   <td>获取一个五元组序列形式的地址信息</td> 
  </tr> 
  <tr> 
   <td>getnameinfo()</td> 
   <td>给定一个套接字地址，返回（主机名，端口号）二元组</td> 
  </tr> 
  <tr> 
   <td>getfqdn()</td> 
   <td>返回完整的域名</td> 
  </tr> 
  <tr> 
   <td>gethostname()</td> 
   <td>返回当前主机名</td> 
  </tr> 
  <tr> 
   <td>gethostbyname()</td> 
   <td>将一个主机名映射到它的 IP 地址</td> 
  </tr> 
  <tr> 
   <td>gethostbyname_ex()</td> 
   <td>gethostbyname()的扩展版本，它返回主机名、别名主机集合和 IP 地址列表</td> 
  </tr> 
  <tr> 
   <td>gethostbyaddr()</td> 
   <td>将一个 IP 地址映射到 DNS 信息；返回与 gethostbyname_ex()相同的 3 元组</td> 
  </tr> 
  <tr> 
   <td>getprotobyname()</td> 
   <td>将一个协议名（如‘tcp’）映射到一个数字</td> 
  </tr> 
  <tr> 
   <td>getservbyname()/getservbyport()</td> 
   <td>将一个服务名映射到一个端口号，或者反过来；对于任何一个函数来说，协议名都是可选的</td> 
  </tr> 
  <tr> 
   <td>ntohl()/ntohs()</td> 
   <td>将来自网络的整数转换为主机字节顺序</td> 
  </tr> 
  <tr> 
   <td>htonl()/htons()</td> 
   <td>将来自主机的整数转换为网络字节顺序</td> 
  </tr> 
  <tr> 
   <td>inet_aton()/inet_ntoa()</td> 
   <td>将 IP 地址八进制字符串转换成 32 位的包格式，或者反过来（仅用于 IPv4 地址）</td> 
  </tr> 
  <tr> 
   <td>inet_pton()/inet_ntop()</td> 
   <td>将 IP地址字符串转换成打包的二进制格式，或者反过来（同时适用于 IPv4 和 IPv6 地址）</td> 
  </tr> 
  <tr> 
   <td>getdefaulttimeout()/setdefaulttimeout()</td> 
   <td>以秒（浮点数）为单位返回默认套接字超时时间；以秒（浮点数）为单位设置默认套接字超时时间</td> 
  </tr> 
 </tbody> 
</table>

## 2.2 \*SocketServer 模块 ##

SocketServer 是标准库中的一个高级模块（Python 3.x 中重命名为 socketserver），它的目标是简化很多样板代码，它们是创建网络客户端和服务器所必需的代码。这个模块中有为你创建的各种各样的类。

<table> 
 <thead> 
  <tr> 
   <th>类</th> 
   <th>描 述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>BaseServer</td> 
   <td>包含核心服务器功能和 mix-in 类的钩子；仅用于推导，这样不会创建这个类的实例；可以用 TCPServer 或 UDPServer</td> 
  </tr> 
  <tr> 
   <td>TCPServer/UDPServer</td> 
   <td>基础的网络同步 TCP/UDP 服务器</td> 
  </tr> 
  <tr> 
   <td>UnixStreamServer/UnixDatagramServer</td> 
   <td>基于文件的基础同步 TCP/UDP 服务器</td> 
  </tr> 
  <tr> 
   <td>ForkingMixIn/ThreadingMixIn</td> 
   <td>核心派出或线程功能；只用作 mix-in 类与一个服务器类配合实现一些异步性；不能直接实例化这个类</td> 
  </tr> 
  <tr> 
   <td>ForkingTCPServer/ForkingUDPServer</td> 
   <td>ForkingMixIn 和 TCPServer/UDPServer 的组合</td> 
  </tr> 
  <tr> 
   <td>ThreadingTCPServer/ThreadingUDPServer</td> 
   <td>ThreadingMixIn 和 TCPServer/UDPServer 的组合</td> 
  </tr> 
  <tr> 
   <td>BaseRequestHandler</td> 
   <td>包含处理服务请求的核心功能；仅仅用于推导，这样无法创建这个类的实例；可以使用 StreamRequestHandler 或 DatagramRequestHandler</td> 
  </tr> 
  <tr> 
   <td>StreamRequestHandler/DatagramRequestHandler</td> 
   <td>实现 TCP/UDP 服务器的服务处理器</td> 
  </tr> 
 </tbody> 
</table>

### 2.2.1 创建 SocketServer TCP 服务器 ###

#### SocketServer 时间戳 TCP 服务器 ####

# SocketServer 时间戳 TCP 服务器
    from socketserver import TCPServer as TCP, StreamRequestHandler as SRH
    from time import ctime
    
    HOST = ''
    PORT = 21567
    ADDR = (HOST, PORT)
    
    
    # MyRequestHandler作为SocketServer中StreamRequestHandler 的一个子类，并重写了它的 handle()方法
    class MyRequestHandler(SRH):
        def handle(self):
            print('...connected from:',
                  self.client_address,
                  self.wfile.write(bytes('[%s] %s' % (ctime(), self.rfile.readline()), 'utf-8')))
    
    
    # 创建 TCP 服务器
    tcpServ = TCP(ADDR, MyRequestHandler)
    print('waiting for connection...')
    # 无限循环地等待并服务于客户端请求
    tcpServ.serve_forever()

### 2.2.2 创建 SocketServer TCP 客户端 ###

#### SocketServer 时间戳 TCP 客户端 ####

# SocketServer 时间戳 TCP 客户端
    from socket import *
    
    HOST = 'localhost'
    PORT = 21567
    BUFSIZ = 1024
    ADDR = (HOST, PORT)
    
    while True:
        # 分配 TCP 客户端套接字
        tcpCliSock = socket(AF_INET, SOCK_STREAM)
        # 主动调用并连接到服务器
        tcpCliSock.connect(ADDR)
        data = input('>')
        if not data:
            break
        tcpCliSock.send(bytes('%s\r\n' % data, 'utf-8'))
        data = tcpCliSock.recv(BUFSIZ)
        if not data:
            break
        print(data.strip())
        tcpCliSock.close()

## 2.3 \*Twisted 框架介绍 ##

Twisted 是一个完整的事件驱动的网络框架，利用它既能使用也能开发完整的异步网络应用程序和协议。因为它还不是 Python 标准库的一部分，所以必须单独下载并安装它。它提供了大量的支持来建立完整的系统，包括网络协议、线程、安全性和身份验证、聊天/ IM、 DBM 及 RDBMS 数据库集成、 Web/因特网、电子邮件、命令行参数、 GUI 集成工具包等。

### 2.3.1 创建 Twisted Reactor TCP 服务器 ###

#### Twisted Reactor 时间戳 TCP 服务器 ####

# Twisted Reactor 时间戳 TCP 服务器
    from twisted.internet import protocol, reactor
    from time import ctime
    
    PORT = 21567
    
    
    class TSServProtocol(protocol.Protocol):
        def connectionMade(self):
            clnt = self.clnt = self.transport.getPeer().host
            print('...connected from:', clnt)
    
        def dataReceived(self, data):
            self.transport.write(bytes('[%s] %s' % (ctime(), data), 'utf-8'))
    
    
    factory = protocol.Factory()
    factory.protocol = TSServProtocol
    print('waiting for connection...')
    reactor.listenTCP(PORT, factory)
    reactor.run()

### 2.3.2 创建 Twisted Reactor TCP 客户端 ###

#### Twisted Reactor 时间戳 TCP 客户端 ####

# Twisted Reactor 时间戳 TCP 客户端
    from click._compat import raw_input
    from twisted.internet import protocol, reactor
    
    HOST = 'localhost'
    PORT = 21567
    
    
    class TSClntProtocol(protocol.Protocol):
        def sendData(self):
            data = raw_input('>')
            if data:
                print('...sending %s...' % data)
                self.transport.write(bytes(data, 'utf-8'))
            else:
                self.transport.loseConnection()
    
        def connectionMade(self):
            self.sendData()
    
        def dataReceived(self, data):
            print(data)
            self.sendData()
    
    
    class TSClntFactory(protocol.ClientFactory):
        protocol = TSClntProtocol
        clientConnectionLost = clientConnectionFalied = lambda self, connector, reason: reactor.stop()
    
    
    reactor.connectTCP(HOST, PORT, TSClntFactory())
    reactor.run()

end