socket

作者: 蜗牛_151a | 来源:发表于2018-07-27 17:04 被阅读0次

socket

基本的client客户端

创建client.py和server.py文件，先运行服务端server，再运行客户端client

#!_*_coding:utf-8_*_
import socket   #导入socket
client=socket.socket()  #建立服务
is_port=('127.0.0.1',6969)
client.connect(is_port)  #连接服务端地址（ip和端口） 
conn.sendall(b'Hello World') #发送数据
data=client.recv(1024) #一次发送多少个字节
print("recv:",data) #服务端应答给客户端的数据
client.close() #关闭客户端
#执行结果
#('recv:', 'What are you doing')

基本的server服务端

#!_*_coding:utf-8_*_
import socket   #导入socket
server=socket.socket()  #建立服务
is_port=('127.0.0.1',6969)
server.bind(is_port)  #绑定服务端地址（ip和端口）
server.listen(5)  #监听客户端请求，这里表示最多可以同时接受五个客户端的请求
print("我要开始等电话了")
conn,addr=server.accept() #等待响应
print(conn,addr)
print("电话来了" )
data=conn.recv(1024) #一次接受多少个字节
print("recv",data) #服务端接受的客户端数据
conn.sendall("What are you dong")  #返回给客户端数据
server.close()  #关闭服务
#执行结果
#我要开始等电话了
#(<socket._socketobject object at 0x0000000005ACD730>, ('127.0.0.1', 3210))
#电话来了
#('recv', 'Hello World')

终上所述，会发现客户端和服务端实现了简单的一次会话

循环监听

这里最好是在linux系统下运行，windows下的表现会有所不同
windows下客户端断开服务端也会跟着断开，服务端接受不到任何数据，直接抛出异常，服务端直接断开
linux会返回一个空数据，从而可以根据它判断（if not data），如果为空，这打印 print("client has lost...")返回到监听处，继续等待客户端的请求

服务端

#-*- coding:utf-8 -*-
import socket
import os
#服务端
ip_port = ('127.0.0.1', 8888)
server = socket.socket()
server.bind(ip_port)  # 绑定要监听的端口
server.listen(5)#最多只能挂起5个客户端
print("我要开始等电话了")
while True:
    conn, addr = server.accept()#addr打印出客户端请求地址
    print(conn, addr)
    print("电话来了")
    count=0
    while True:#这个循环监听的是一个客户端对一个服务端可进行多次对话
        data = conn.recv(1024)
        print(data)
        if not data:#当客户端断开的情况
            print("client has lost...")
            break
        conn.sendall(data)
server.close()

客户端

#!_*_coding:utf-8_*_
import socket
client = socket.socket()
is_port = ("127.0.0.1", 8888)
client.connect(is_port)
while True:
    content = raw_input(">>:").strip()
    if len(content) == 0: continue
    client.send(content)
    data = client.recv(1024)
    print("recv:", data)
client.close()

用原生socekt实现一个简单的ssh

服务端

#!-*-coding:utf-8-*-
import socket, os
server=socket.socket()
is_port=("127.0.0.1",9999)
server.bind(is_port)
server.listen(5)
while True:#等一次会话结束后不立马关闭服务端，而是进入监听状态，继续监听客户端发送来的请求
    conn,addr=server.accept()
    print("new conn:",addr)
    while True:
        print("等待新指令")
        data=conn.recv(1024)
        if not data:#在没有等待到指令的情况下
            print("客户端已断开")
            break
        print("执行指令:",data)
        cmd_res=os.popen(data.decode()).read()
        print("before send",len(cmd_res))
        if len(cmd_res)==0:#如果os.popen()不能识别该指令
            cmd_res="cmd has no output..."
        conn.send(str(len(cmd_res)))#先发送输出的长度
        client_ack=conn.recv(1024)#处理避免粘包问题，即两次发送的数据当做一次发送
        conn.send(cmd_res)#发送输出的内容
        print("send done")
server.close()

客户端

#!_*_coding:utf-8_*_
import socket

client = socket.socket()
is_port = ("127.0.0.1", 9999)
client.connect(is_port)
while True:
    cmd = raw_input(">>:").strip()
    if len(cmd) == 0: continue
    client.send(cmd)
    cmd_res_size = client.recv(1024)
    client.send("收到了命令大小后，开始接受，粘包处理")
    received_size = 0
    received_data = ''
    index=0
    while received_size < int(cmd_res_size):
 #由于客户端一次最多只能接受1024个字节，如果超出做循环接受处理
 #这里也是为什么发送数据要先发送数据字节的长度
        data = client.recv(1024)
        received_size += len(data)
        received_data += data
        index += 1
    else:
        print("count",index)#这里应该是两次
        print("cmd res receive done...", received_size)
        print(received_data.decode("gbk").encode("utf-8") )
client.close()

![输出的数据有粘包的情况.png]

image.png

IO多路复用

I/O多路复用指：通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。

Linux
Linux中的 select，poll，epoll 都是IO多路复用的机制。

Python

Python中有一个select模块，其中也提供了：select、poll、epoll三个方法，分别调用系统的 select，poll，epoll 从而实现IO多路复用。

Windows Python：
    提供： select
Mac Python：
    提供： select
Linux Python：
    提供： select、poll、epoll
#注意：网络操作、文件操作、终端操作等均属于IO操作，对于windows只支持Socket操作
#其他系统支持其他IO操作，但是无法检测 普通文件操作 自动上次读取是否已经变化。

对于select方法：

句柄列表11, 句柄列表22, 句柄列表33 = select.select(句柄序列1, 句柄序列2, 句柄序列3, 超时时间)
 
参数： 可接受四个参数（前三个必须）
返回值：三个列表
 
select方法用来监视文件句柄，如果句柄发生变化，则获取该句柄。
1、当 参数1 序列中的句柄发生可读时（accetp和read），则获取发生变化的句柄并添加到 返回值1 序列中
2、当 参数2 序列中含有句柄时，则将该序列中所有的句柄添加到 返回值2 序列中
3、当 参数3 序列中的句柄发生错误时，则将该发生错误的句柄添加到 返回值3 序列中
4、当 超时时间 未设置，则select会一直阻塞，直到监听的句柄发生变化,
   当 超时时间 ＝ 1时，那么如果监听的句柄均无任何变化，则select会阻塞 1 秒，
   之后返回三个空列表，如果监听的句柄有变化，则直接执行。

利用select实现伪同时处理多个Socket客户端请求：服务端

# -*- coding:utf-8 -*-

import socket
import select

sk1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sk1.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sk1.bind(('127.0.0.1',8002))
sk1.listen(5)
sk1.setblocking(0)#为非阻塞模式

inputs = [sk1,]

while True:
    readable_list, writeable_list, error_list = select.select(inputs, [], inputs, 1)
    for r in readable_list:
        # 当客户端第一次连接服务端时
        if sk1 == r:
            print 'accept'
            request, address = r.accept()
            request.setblocking(0)
            inputs.append(request)
        # 当客户端连接上服务端之后，再次发送数据时
        else:
            received = r.recv(1024)
            # 当正常接收客户端发送的数据时
            if received:
                print 'received data:', received
            # 当客户端关闭程序时
            else:
                inputs.remove(r)
sk1.close()

利用select实现伪同时处理多个Socket客户端请求：客户端

# -*- coding:utf-8 -*-
import socket

ip_port = ('127.0.0.1',8002)
sk = socket.socket()
sk.connect(ip_port)

while True:
    inp = raw_input('please input:')
    sk.sendall(inp)
sk.close()

此处的Socket服务端相比与原生的Socket，他支持当某一个请求不再发送数据时，服务器端不会等待而是可以去处理其他请求的数据。但是，如果每个请求的耗时比较长时，select版本的服务器端也无法完成同时操作。

基于select实现的服务端

#!/usr/bin/env python
#coding:utf8

'''
 服务器的实现 采用select的方式
'''

import select
import socket
import sys
import Queue

#创建套接字并设置该套接字为非阻塞模式

server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.setblocking(0)

#绑定套接字
server_address = ('localhost',10000)
print >>sys.stderr,'starting up on %s port %s'% server_address
server.bind(server_address)

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

server.listen(5)

#初始化读取数据的监听列表,最开始时希望从server这个套接字上读取数据
inputs = [server]

#初始化写入数据的监听列表，最开始并没有客户端连接进来，所以列表为空

outputs = []

#要发往客户端的数据
message_queues = {}
while inputs:
    print >>sys.stderr,'waiting for the next event'
    #调用select监听所有监听列表中的套接字，并将准备好的套接字加入到对应的列表中
    readable,writable,exceptional = select.select(inputs,outputs,inputs)#列表中的socket 套接字  如果是文件呢？ 
    #监控文件句柄有某一处发生了变化 可写 可读  异常属于Linux中的网络编程 
    #属于同步I/O操作，属于I/O复用模型的一种
    #rlist--等待到准备好读
    #wlist--等待到准备好写
    #xlist--等待到一种异常
    #处理可读取的套接字

    '''
        如果server这个套接字可读，则说明有新链接到来
        此时在server套接字上调用accept,生成一个与客户端通讯的套接字
        并将与客户端通讯的套接字加入inputs列表，下一次可以通过select检查连接是否可读
        然后在发往客户端的缓冲中加入一项，键名为:与客户端通讯的套接字，键值为空队列
        select系统调用是用来让我们的程序监视多个文件句柄(file descrīptor)的状态变化的。程序会停在select这里等待，
        直到被监视的文件句柄有某一个或多个发生了状态改变
        '''

    '''
        若可读的套接字不是server套接字,有两种情况:一种是有数据到来，另一种是链接断开
        如果有数据到来,先接收数据,然后将收到的数据填入往客户端的缓存区中的对应位置，最后
        将于客户端通讯的套接字加入到写数据的监听列表:
        如果套接字可读.但没有接收到数据，则说明客户端已经断开。这时需要关闭与客户端连接的套接字
        进行资源清理
        '''
        
    for s in readable: 
        if s is server:
            connection,client_address = s.accept()
            print >>sys.stderr,'connection from',client_address
            connection.setblocking(0)#设置非阻塞
            inputs.append(connection)
            message_queues[connection] = Queue.Queue()
        else:
            data = s.recv(1024)
            if data:
                print >>sys.stderr,'received "%s" from %s'% \
                (data,s.getpeername())
                message_queues[s].put(data)
                if s not in outputs:
                    outputs.append(s)
            else:
                print >>sys.stderr,'closing',client_address
                if s in outputs:
                    outputs.remove(s)
                inputs.remove(s)
                s.close()
                del message_queues[s]
                    
    #处理可写的套接字
    '''
        在发送缓冲区中取出响应的数据，发往客户端。
        如果没有数据需要写，则将套接字从发送队列中移除，select中不再监视
        '''

    for s in writable:
        try:
            next_msg = message_queues[s].get_nowait()

        except Queue.Empty:
            print >>sys.stderr,'  ',s,getpeername(),'queue empty'
            outputs.remove(s)
        else:
            print >>sys.stderr,'sending "%s" to %s'% \
            (next_msg,s.getpeername())
            s.send(next_msg)



    #处理异常情况

    for s in exceptional:
        for s in exceptional:
            print >>sys.stderr,'exception condition on',s.getpeername()
            inputs.remove(s)
            if s in outputs:
                outputs.remove(s)
            s.close()
            del message_queues[s]

socket不能实现多用户同时请求数据，需要等待第一个客户端会话完毕后再处理第二个，以此类推。不能实现多并发

socketserver

+------------------+
|   DaseServer     |
+------------------+
         |
         v
+------------------+               +------------------+
|     TCPServer    | ----------->  | UnixStreamServer |  
+------------------+               +------------------+
         |
         v
+------------------+               +--------------------+
|     UDPServer    | ----------->  | UnixDatagramServer |  
+------------------+               +--------------------+

第一步，你必须创建一个请求处理类，并且这个类要继承BaseRequestHandler,并且还要重写父类里的handler()
第二步，你必须实例化一个server类（如TCPServer)，并且传递server IP和你上面创建的请求处理类给这个实例化的server类
然后，用server.handle_request() #只处理一个请求或者 server。serve_forever()#处理多个请求，永远执行
最后，用server_close()关闭这个socket

socketserver code python3

import socketserver

class MyTCPHandler(socketserver.BaseRequestHandler):
    """
    The request handler class for our server.

    It is instantiated once per connection to the server, and must
    override the handle() method to implement communication to the
    client.
    """

    def handle(self):
      while True:
        # self.request is the TCP socket connected to the client
        self.data = self.request.recv(1024).strip()
        print("{} wrote:".format(self.client_address[0]))
        print(self.data)
        if not self.data:
            print(self.client_address,"client closed")
            break
        # just send back the same data, but upper-cased
        self.request.sendall(self.data.upper())

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999
    # Create the server, binding to localhost on port 9999
    # server = socketserver.TCPServer((HOST, PORT), MyTCPHandler)
    server = socketserver.ThreadingTCPServer((HOST, PORT), MyTCPHandler)
    #ThreadingTCPServer实现多并发
    # Activate the server; this will keep running until you
    # interrupt the program with Ctrl-C
    server.serve_forever()

socketserver code python2.7

# !_*_coding:utf-8_*_
import SocketServer

class MyTCPHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        while True:
            try:
                self.data = self.request.recv(1024)
                print("{} wrote:".format(self.client_address[0]))
                print(self.data)
                if not self.data:  # 客户端不阻塞且没有发送数据，则表示断开了
                    print(self.client_address, "client closed")
                    break
                self.request.sendall(self.data.upper())
            except Exception:
                print 'A client has left!!!'
                break


HOST, PORT = "localhost", 9999
server =SocketServer.ThreadingTCPServer((HOST, PORT), MyTCPHandler)
server.serve_forever()

socket

socket

基本的client客户端

基本的server服务端

循环监听

用原生socekt实现一个简单的ssh

更多功能

IO多路复用

利用select实现伪同时处理多个Socket客户端请求：服务端

利用select实现伪同时处理多个Socket客户端请求：客户端

基于select实现的服务端

socketserver

socketserver code python3

socketserver code python2.7

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读