socket网络编程

Bertha 。 2021-12-24 13:43 577阅读 0赞

socket

网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket。

建立网络通信连接至少要一对端口号(socket)。socket本质是编程接口(API)，对TCP/IP的封装，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口；HTTP是轿车，提供了封装或者显示数据的具体形式；Socket是发动机，提供了网络通信的能力。

socket和file的区别：

  • file模块是针对某个指定文件进行【打开】【读写】【关闭】
  • socket模块是针对 服务器端 和 客户端Socket 进行【打开】【读写】【关闭】

1238847-20171115171731687-1651570016.png

ContractedBlock.gif ExpandedBlockStart.gif

  1. # -*-coding:utf-8-*-
  2. # Author:sunhao
  3. import socket
  5. serve = socket.socket()
  7. serve.bind(('localhost', 6969))
  9. serve.listen()
  11. print("我要开始等电话")
  13. conn, addr = serve.accept()  # conn就是客户端链接过来而在服务器端为其生成的一个连接实例
  15. print(conn, addr)
  17. while True:
  18.     data = conn.recv(1024)
  19.     print(data.decode())
  21.     conn.send(data.upper())
  23. serve.close()

socket-server

ContractedBlock.gif ExpandedBlockStart.gif

  1. # -*-coding:utf-8-*-
  2. # Author:sunhao
  4. import socket
  6. ip_port=('localhost',6969)
  8. client=socket.socket()
  10. client.connect(ip_port)
  12. while True:
  14.     msg=input(">>:").strip()
  16.     client.send(msg.encode("utf-8"))
  18.     data=client.recv(1024)
  19.     print(data.decode())
  20. client.close()

socket-client

更多socket方法：

sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)

  1. 1 参数一：地址簇
  2.  2 
  3.  3 　　socket.AF_INET IPv4（默认）
  4.  4 　　socket.AF_INET6 IPv6
  5.  5 
  6.  6 　　socket.AF_UNIX 只能够用于单一的Unix系统进程间通信
  7.  7 
  8.  8 参数二：类型
  9.  9 
  10. 10 　　socket.SOCK_STREAM　　流式socket , for TCP （默认）
  11. 11 　　socket.SOCK_DGRAM　　 数据报式socket , for UDP
  12. 12 
  13. 13 　　socket.SOCK_RAW 原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。
  14. 14 　　socket.SOCK_RDM 是一种可靠的UDP形式，即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问，在需要执行某些特殊操作时使用，如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。
  15. 15 　　socket.SOCK_SEQPACKET 可靠的连续数据包服务
  16. 16 
  17. 17 参数三：协议
  18. 18 
  19. 19 　　0　　（默认）与特定的地址家族相关的协议,如果是 0 ，则系统就会根据地址格式和套接类别,自动选择一个合适的协议

sk.bind(address)

　　sk.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。

sk.listen(backlog)

　　开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。

backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5
这个值不能无限大，因为要在内核中维护连接队列

sk.setblocking(bool)

　　是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。

sk.accept()

　　接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。

　　接收TCP 客户的连接（阻塞式）等待连接的到来

sk.connect(address)

　　连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。

sk.connect_ex(address)

　　同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061

sk.close()

　　关闭套接字

sk.recv(bufsize[,flag])

　　接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。

sk.recvfrom(bufsize[.flag])

　　与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。

sk.send(string[,flag])

　　将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。

sk.sendall(string[,flag])

　　将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。

内部通过递归调用send，将所有内容发送出去。

sk.sendto(string[,flag],address)

　　将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。

sk.settimeout(timeout)

　　设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）

sk.getpeername()

　　返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。

sk.getsockname()

　　返回套接字自己的地址。通常是一个元组(ipaddr,port)

sk.fileno()

　　套接字的文件描述符

socket实现多连接

ContractedBlock.gif ExpandedBlockStart.gif

  1. # -*-coding:utf-8-*-
  2. # Author:sunhao
  4. import socket
  5. import os
  7. server = socket.socket()
  9. ip_port = ('127.0.0.1',6969)
  11. server.bind(ip_port)
  13. server.listen()
  15. while True:
  17.     conn,f = server.accept()    #多连接,阻塞
  18.     print("new connect:",f)
  20.     while True:
  21.         print("等待新指令")
  23.         data = conn.recv(1024)
  24.         if not data:
  25.             print("客户端断开")
  27.             break
  28.         print("执行指令",data)
  30.         res = os.popen(data.decode()).read()
  33.         print("before send",len(res.encode()))
  37.         if len(res) == 0:
  38.             res = "没有改指令，请重新输入:"
  40.         conn.send(str(len(res.encode())).encode('utf-8'))   #先发数据大小给客户端    会发生粘包
  42.         client_ack=conn.recv(1024)     #解决粘包
  43.         print(client_ack.decode())
  44.         conn.send(res.encode("utf-8"))                  #再发数据
  46.         print("send done")
  49. server.close()

socket-实现多连接服务端

ContractedBlock.gif ExpandedBlockStart.gif

  1. # -*-coding:utf-8-*-
  2. # Author:sunhao
  4. import socket
  7. client = socket.socket()
  8. ip_port = ('127.0.0.1',6969)
  10. client.connect(ip_port)
  12. print("连接开始")
  14. while True:
  16.     command = input(">>:").strip()
  18.     if len(command) == 0:
  19.         continue
  21.     client.send(command.encode("utf-8"))
  23.     cmd_res_size=client.recv(1024)  # 接受命令结果的长度
  25.     print("命令结果的大小",cmd_res_size)
  27.     client.send("准备好接收了".encode('utf-8'))
  29.     recived_size=0
  30.     recived_data=b''
  32.     while recived_size < int(cmd_res_size.decode()):
  34.         print("----------",cmd_res_size.decode())
  35.         print("##############", type(cmd_res_size.decode()))
  37.         data=client.recv(1024)
  39.         print("&&&&&&&&&&",len(data))
  41.         recived_size += len(data)  # 每次收到的有可能小于1024 所以用len判断
  42.         recived_data += data
  46.     else:
  48.         print("cmd recive done",recived_size)
  50.         print(recived_data.decode())
  53. client.close()

socket实现多连接客户端

socket实现简单FTP文件传输

ContractedBlock.gif ExpandedBlockStart.gif

  1. # -*-coding:utf-8-*-
  2. # Author:sunhao
  4. import socket,hashlib
  5. import os
  7. server = socket.socket()
  9. ip_port = ('127.0.0.1',6969)
  11. server.bind(ip_port)
  13. server.listen()
  15. while True:
  17.     conn,f = server.accept()
  18.     print("new connect:",f)
  20.     while True:
  21.         print("等待新指令")
  23.         data = conn.recv(1024)
  24.         if not data:
  25.             print("客户端断开")
  27.             break
  28.         print("执行指令",data)
  30.         cmd,filename = data.decode().split()
  31.         print(filename)
  33.         if os.path.isfile(filename):
  35.             f=open(filename,"rb")
  37.             file_size=os.stat(filename).st_size   # 判断文件大小
  38.             conn.send(str(file_size).encode('utf-8'))  # 发文件大小
  39.             conn.recv(1024)      # waiting for ack
  40.             m = hashlib.md5()      # md5加密 判断客户端发送的与服务器收到的md5加密后是否一样
  42.             for line in f:
  43.                 m.update(line)
  44.                 conn.send(line)
  46.             print("file md5:",m.hexdigest())
  48.             f.close()
  50.             conn.send(m.hexdigest().encode())    # send to 客户端
  52.         print("send done")
  55. server.close()

socket实现简单FTP—服务端

ContractedBlock.gif ExpandedBlockStart.gif

  1. # -*-coding:utf-8-*-
  2. # Author:sunhao
  4. import socket,hashlib
  7. client = socket.socket()
  8. ip_port = ('127.0.0.1',6969)
  10. client.connect(ip_port)
  12. print("连接开始")
  13. while True:
  15.     get_file = input(">>>:").strip()
  17.     if len(get_file) == 0:
  18.         continue
  20.     if get_file.startswith('get'):
  21.         client.send(get_file.encode("utf-8"))
  22.         server_response= client.recv(1024)  # 接受文件大小的长度
  23.         print("文件打的大小", server_response)
  25.         client.send("准备好接收了".encode('utf-8'))
  27.         recived_size = 0
  29.         total_size=int(server_response.decode())
  30.         filename=get_file.split()[1]
  31.         f=open(filename+".new",'wb')
  32.         m = hashlib.md5()
  34.         while recived_size < total_size:
  36.             if total_size -recived_size > 1024:
  38.                 size=1024
  39.             else:
  40.                 size=total_size-recived_size
  43.             data = client.recv(size)
  45.             m.update(data)
  48.             recived_size += len(data)  #每次收到的有可能小于1024 所以用len判断
  50.             f.write(data)
  53.         else:
  55.             client_file_md5 = m.hexdigest()
  57.             print("file recived done",recived_size)
  58.             f.close()
  60.         server_file_md5 = client.recv(1024)
  62.         print("server file md5:",server_file_md5)
  63.         print("server file md5:",client_file_md5)
  66. client.close()

socket实现简单FTP—客户端

socketserver模块

SocketServer内部使用 IO多路复用 以及 “多线程” 和 “多进程” ，从而实现并发处理多个客户端请求的Socket服务端。即：每个客户端请求连接到服务器时，Socket服务端都会在服务器是创建一个“线程”或者“进程” 专门负责处理当前客户端的所有请求。

虽说用Python编写简单的网络程序很方便，但复杂一点的网络程序还是用现成的框架比较好。这样就可以专心事务逻辑，而不是套接字的各种细节。SocketServer模块简化了编写网络服务程序的任务。同时SocketServer模块也是Python标准库中很多服务器框架的基础。

ThreadingTCPServer

ThreadingTCPServer实现的Soket服务器内部会为每个client创建一个 “线程”，该线程用来和客户端进行交互。

使用ThreadingTCPServer:

  • 创建一个继承自 SocketServer.BaseRequestHandler 的类
  • 类中必须定义一个名称为 handle 的方法
  • 启动ThreadingTCPServer

实例：

ContractedBlock.gif ExpandedBlockStart.gif

  1. # -*-coding:utf-8-*-
  2. # Author:sunhao
  4. import socketserver
  6. class MyTCPHandler(socketserver.BaseRequestHandler):
  9.         def handle(self):
  10.             print(self.request)
  12.             while True:
  13.                 conn=self.request
  15.                 try:
  17.                     data=conn.recv(1024).strip()
  19.                     print(data)
  21.                     conn.sendall(data.upper())
  23.                 except ConnectionAbortedError as e:
  25.                     print("出错额",e)
  26.                     break
  31. if __name__ == "__main__":
  33.     HOST,PORT = '127.0.0.1',9999
  35.     server=socketserver.ThreadingTCPServer((HOST,PORT),MyTCPHandler)  #创建socket连接
  37.     server.serve_forever()

socket_server服务端

ThreadingTCPServer源码剖析

ThreadingTCPServer的类图关系如下：

1238847-20171117134150031-1240030271.png

内部调用流程为：

  • 启动服务端程序
  • 执行 TCPServer.__init__ 方法，创建服务端Socket对象并绑定 IP 和 端口
  • 执行 BaseServer.__init__ 方法，将自定义的继承自SocketServer.BaseRequestHandler 的类 MyRequestHandle赋值给self.RequestHandlerClass
  • 执行 BaseServer.server_forever 方法，While 循环一直监听是否有客户端请求到达 …
  • 当客户端连接到达服务器
  • 执行 ThreadingMixIn.process_request 方法，创建一个 “线程” 用来处理请求

  • 执行 ThreadingMixIn.process_request_thread 方法

  • 在process_request_thread方法里面执行 BaseServer.finish_request 方法，执行 self.RequestHandlerClass() 即：执行 自定义 MyRequestHandler 的构造方法（自动调用基类BaseRequestHandler的构造方法，在该构造方法中又会调用 MyRequestHandler的handle方法）

ThreadingTCPServer相关源码：

ContractedBlock.gif ExpandedBlockStart.gif

  1. class BaseServer:
  3.     """Base class for server classes.
  5.     Methods for the caller:
  7.     - __init__(server_address, RequestHandlerClass)
  8.     - serve_forever(poll_interval=0.5)
  9.     - shutdown()
  10.     - handle_request()  # if you do not use serve_forever()
  11.     - fileno() -> int   # for select()
  13.     Methods that may be overridden:
  15.     - server_bind()
  16.     - server_activate()
  17.     - get_request() -> request, client_address
  18.     - handle_timeout()
  19.     - verify_request(request, client_address)
  20.     - server_close()
  21.     - process_request(request, client_address)
  22.     - shutdown_request(request)
  23.     - close_request(request)
  24.     - handle_error()
  26.     Methods for derived classes:
  28.     - finish_request(request, client_address)
  30.     Class variables that may be overridden by derived classes or
  31.     instances:
  33.     - timeout
  34.     - address_family
  35.     - socket_type
  36.     - allow_reuse_address
  38.     Instance variables:
  40.     - RequestHandlerClass
  41.     - socket
  43.     """
  45.     timeout = None
  47.     def __init__(self, server_address, RequestHandlerClass):
  48.         """Constructor.  May be extended, do not override."""
  49.         self.server_address = server_address
  50.         self.RequestHandlerClass = RequestHandlerClass
  51.         self.__is_shut_down = threading.Event()
  52.         self.__shutdown_request = False
  54.     def server_activate(self):
  55.         """Called by constructor to activate the server.
  57.         May be overridden.
  59.         """
  60.         pass
  62.     def serve_forever(self, poll_interval=0.5):
  63.         """Handle one request at a time until shutdown.
  65.         Polls for shutdown every poll_interval seconds. Ignores
  66.         self.timeout. If you need to do periodic tasks, do them in
  67.         another thread.
  68.         """
  69.         self.__is_shut_down.clear()
  70.         try:
  71.             while not self.__shutdown_request:
  72.                 # XXX: Consider using another file descriptor or
  73.                 # connecting to the socket to wake this up instead of
  74.                 # polling. Polling reduces our responsiveness to a
  75.                 # shutdown request and wastes cpu at all other times.
  76.                 r, w, e = _eintr_retry(select.select, [self], [], [],
  77.                                        poll_interval)
  78.                 if self in r:
  79.                     self._handle_request_noblock()
  80.         finally:
  81.             self.__shutdown_request = False
  82.             self.__is_shut_down.set()
  84.     def shutdown(self):
  85.         """Stops the serve_forever loop.
  87.         Blocks until the loop has finished. This must be called while
  88.         serve_forever() is running in another thread, or it will
  89.         deadlock.
  90.         """
  91.         self.__shutdown_request = True
  92.         self.__is_shut_down.wait()
  94.     # The distinction between handling, getting, processing and
  95.     # finishing a request is fairly arbitrary.  Remember:
  96.     #
  97.     # - handle_request() is the top-level call.  It calls
  98.     #   select, get_request(), verify_request() and process_request()
  99.     # - get_request() is different for stream or datagram sockets
  100.     # - process_request() is the place that may fork a new process
  101.     #   or create a new thread to finish the request
  102.     # - finish_request() instantiates the request handler class;
  103.     #   this constructor will handle the request all by itself
  105.     def handle_request(self):
  106.         """Handle one request, possibly blocking.
  108.         Respects self.timeout.
  109.         """
  110.         # Support people who used socket.settimeout() to escape
  111.         # handle_request before self.timeout was available.
  112.         timeout = self.socket.gettimeout()
  113.         if timeout is None:
  114.             timeout = self.timeout
  115.         elif self.timeout is not None:
  116.             timeout = min(timeout, self.timeout)
  117.         fd_sets = _eintr_retry(select.select, [self], [], [], timeout)
  118.         if not fd_sets[0]:
  119.             self.handle_timeout()
  120.             return
  121.         self._handle_request_noblock()
  123.     def _handle_request_noblock(self):
  124.         """Handle one request, without blocking.
  126.         I assume that select.select has returned that the socket is
  127.         readable before this function was called, so there should be
  128.         no risk of blocking in get_request().
  129.         """
  130.         try:
  131.             request, client_address = self.get_request()
  132.         except socket.error:
  133.             return
  134.         if self.verify_request(request, client_address):
  135.             try:
  136.                 self.process_request(request, client_address)
  137.             except:
  138.                 self.handle_error(request, client_address)
  139.                 self.shutdown_request(request)
  141.     def handle_timeout(self):
  142.         """Called if no new request arrives within self.timeout.
  144.         Overridden by ForkingMixIn.
  145.         """
  146.         pass
  148.     def verify_request(self, request, client_address):
  149.         """Verify the request.  May be overridden.
  151.         Return True if we should proceed with this request.
  153.         """
  154.         return True
  156.     def process_request(self, request, client_address):
  157.         """Call finish_request.
  159.         Overridden by ForkingMixIn and ThreadingMixIn.
  161.         """
  162.         self.finish_request(request, client_address)
  163.         self.shutdown_request(request)
  165.     def server_close(self):
  166.         """Called to clean-up the server.
  168.         May be overridden.
  170.         """
  171.         pass
  173.     def finish_request(self, request, client_address):
  174.         """Finish one request by instantiating RequestHandlerClass."""
  175.         self.RequestHandlerClass(request, client_address, self)
  177.     def shutdown_request(self, request):
  178.         """Called to shutdown and close an individual request."""
  179.         self.close_request(request)
  181.     def close_request(self, request):
  182.         """Called to clean up an individual request."""
  183.         pass
  185.     def handle_error(self, request, client_address):
  186.         """Handle an error gracefully.  May be overridden.
  188.         The default is to print a traceback and continue.
  190.         """
  191.         print '-'*40
  192.         print 'Exception happened during processing of request from',
  193.         print client_address
  194.         import traceback
  195.         traceback.print_exc() # XXX But this goes to stderr!
  196.         print '-'*40
  198. BaseServer

BaseServer

ContractedBlock.gif ExpandedBlockStart.gif

  1. class TCPServer(BaseServer):
  3.     """Base class for various socket-based server classes.
  5.     Defaults to synchronous IP stream (i.e., TCP).
  7.     Methods for the caller:
  9.     - __init__(server_address, RequestHandlerClass, bind_and_activate=True)
  10.     - serve_forever(poll_interval=0.5)
  11.     - shutdown()
  12.     - handle_request()  # if you don't use serve_forever()
  13.     - fileno() -> int   # for select()
  15.     Methods that may be overridden:
  17.     - server_bind()
  18.     - server_activate()
  19.     - get_request() -> request, client_address
  20.     - handle_timeout()
  21.     - verify_request(request, client_address)
  22.     - process_request(request, client_address)
  23.     - shutdown_request(request)
  24.     - close_request(request)
  25.     - handle_error()
  27.     Methods for derived classes:
  29.     - finish_request(request, client_address)
  31.     Class variables that may be overridden by derived classes or
  32.     instances:
  34.     - timeout
  35.     - address_family
  36.     - socket_type
  37.     - request_queue_size (only for stream sockets)
  38.     - allow_reuse_address
  40.     Instance variables:
  42.     - server_address
  43.     - RequestHandlerClass
  44.     - socket
  46.     """
  48.     address_family = socket.AF_INET
  50.     socket_type = socket.SOCK_STREAM
  52.     request_queue_size = 5
  54.     allow_reuse_address = False
  56.     def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True):
  57.         """Constructor.  May be extended, do not override."""
  58.         BaseServer.__init__(self, server_address, RequestHandlerClass)
  59.         self.socket = socket.socket(self.address_family,
  60.                                     self.socket_type)
  61.         if bind_and_activate:
  62.             try:
  63.                 self.server_bind()
  64.                 self.server_activate()
  65.             except:
  66.                 self.server_close()
  67.                 raise
  69.     def server_bind(self):
  70.         """Called by constructor to bind the socket.
  72.         May be overridden.
  74.         """
  75.         if self.allow_reuse_address:
  76.             self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
  77.         self.socket.bind(self.server_address)
  78.         self.server_address = self.socket.getsockname()
  80.     def server_activate(self):
  81.         """Called by constructor to activate the server.
  83.         May be overridden.
  85.         """
  86.         self.socket.listen(self.request_queue_size)
  88.     def server_close(self):
  89.         """Called to clean-up the server.
  91.         May be overridden.
  93.         """
  94.         self.socket.close()
  96.     def fileno(self):
  97.         """Return socket file number.
  99.         Interface required by select().
  101.         """
  102.         return self.socket.fileno()
  104.     def get_request(self):
  105.         """Get the request and client address from the socket.
  107.         May be overridden.
  109.         """
  110.         return self.socket.accept()
  112.     def shutdown_request(self, request):
  113.         """Called to shutdown and close an individual request."""
  114.         try:
  115.             #explicitly shutdown.  socket.close() merely releases
  116.             #the socket and waits for GC to perform the actual close.
  117.             request.shutdown(socket.SHUT_WR)
  118.         except socket.error:
  119.             pass #some platforms may raise ENOTCONN here
  120.         self.close_request(request)
  122.     def close_request(self, request):
  123.         """Called to clean up an individual request."""
  124.         request.close()
  126. TCPServer

TCPServer

ContractedBlock.gif ExpandedBlockStart.gif

  1. class ThreadingMixIn:
  2.     """Mix-in class to handle each request in a new thread."""
  4.     # Decides how threads will act upon termination of the
  5.     # main process
  6.     daemon_threads = False
  8.     def process_request_thread(self, request, client_address):
  9.         """Same as in BaseServer but as a thread.
  11.         In addition, exception handling is done here.
  13.         """
  14.         try:
  15.             self.finish_request(request, client_address)
  16.             self.shutdown_request(request)
  17.         except:
  18.             self.handle_error(request, client_address)
  19.             self.shutdown_request(request)
  21.     def process_request(self, request, client_address):
  22.         """Start a new thread to process the request."""
  23.         t = threading.Thread(target = self.process_request_thread,
  24.                              args = (request, client_address))
  25.         t.daemon = self.daemon_threads
  26.         t.start()
  28. ThreadingMixIn

ThreadingMixIn

ContractedBlock.gif ExpandedBlockStart.gif

  1. class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass

ThreadingTCPServer

RequestHandler相关源码

ContractedBlock.gif ExpandedBlockStart.gif

  1. class BaseRequestHandler:
  3.     """Base class for request handler classes.
  5.     This class is instantiated for each request to be handled.  The
  6.     constructor sets the instance variables request, client_address
  7.     and server, and then calls the handle() method.  To implement a
  8.     specific service, all you need to do is to derive a class which
  9.     defines a handle() method.
  11.     The handle() method can find the request as self.request, the
  12.     client address as self.client_address, and the server (in case it
  13.     needs access to per-server information) as self.server.  Since a
  14.     separate instance is created for each request, the handle() method
  15.     can define arbitrary other instance variariables.
  17.     """
  19.     def __init__(self, request, client_address, server):
  20.         self.request = request
  21.         self.client_address = client_address
  22.         self.server = server
  23.         self.setup()
  24.         try:
  25.             self.handle()
  26.         finally:
  27.             self.finish()
  29.     def setup(self):
  30.         pass
  32.     def handle(self):
  33.         pass
  35.     def finish(self):
  36.         pass
  38. SocketServer.BaseRequestHandler

BaseRequestHandler

转载于:https://www.cnblogs.com/sunhao96/p/7839954.html

发表评论

表情：
评论列表 （有 0 条评论，577人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Python Socket 网络编程

    Socket 是进程间通信的一种方式，它与其他进程间通信的一个主要不同是：它能实现不同主机间的进程间通信，我们网络上各种各样的服务大多都是基于 Socket 来完成通信的，例如

    朱雀朱雀/ 0 赞/ 398 阅读

    相关 Socket网络编程基础

    1 网络编程简述 端口 物理端口： 逻辑端口：用于标识进程的逻辑地址，不同进程的标识；有效端口：0~65535，其中0~1024系统使用或保留端口。 java 中i

    矫情吗；*矫情吗；*/ 0 赞/ 442 阅读

    相关 socket网络编程

    socket 网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket。 建立网络通信连接至少要一对端口号(socket)。socket本质

    Bertha 。Bertha 。/ 0 赞/ 578 阅读

    相关 Socket网络编程

    网络编程的概念： 网络编程从大的方面说就是对信息的发送到接收，中间传输为物理线路的作用，编程人员可以不用考虑…… 网络编程最主要的工作就是在发送端把信息通过规定好的协议进行

    朱雀朱雀/ 0 赞/ 607 阅读