进度条 --- socket ---socketserver

时间:2021-08-19 01:01:21

TCP:可靠的面向连接的协议,传输效率低,全双工通信,流数据传输。运用:web浏览器,电子邮件,文件传输程序

UDP:不可靠的,无连接的服务,传输效率高,面向数据包的传输,只能发短消息。运用:dns , 视频流 ,IP语音(VoIP)

  根据MTU最大传输单元为1500(普遍),再减去报头,报尾,所以udp传输最多是1470余

tcp和udp的对比

tcp:交换数据前,必须先经过三次握手,tcp提供超时重发,丢弃重复数据,有检验数据,流控制功能

  数据传输必须先要得到对方的确认,有时候网络问题,会造成数据的多次发送,断开必须四次挥手

udp:用户数据报协议,它只负责将数据传输出去,但是能不能到达目的地,它不会管,没有握手和挥手的原因,传输速度就会很快

socket

socket层,是应用层与tcp/ip 协议簇中间的软件抽象层,它是一组接口

1 基于tcp的socket

服务端:

conn,client_addr=sk.accept()
conn:
<socket.socket fd=520, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 54805)>
client_addr:('127.0.0.1', 54805)
import socket
sk=socket.socket() #默认使用tcp模式
sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #表示重用IP和端口,写在bind之前
sk.bind(('127.0.0.1',9000)) #绑定ip和端口,必须是一个元组,
sk.listen() #监听,在pycharm3.4之后的版本,里面可以不写,要写的话,表示监听的链接数 conn,addr=sk.accept() #接收客户端链接 ,经历了 3 次握手
ret=conn.recv(1024) #接收客户端信息
print(ret)
conn.send(b'hello') #向客户端发送信息 conn.close() #关闭客户端套接字,经历了 4 次挥手
sk.close() #关闭服务器套接字

客户端:

import socket
sk=socket.socket()
sk.connect(('127.0.0.1',9000)) ret=sk.recv(1024).decode('utf-8')
sk.send('hello'.encode('utf-8')) sk.close()

对于一个tcp而言,客户端和server是一直被占用的,换句话说链接是阻塞的,其他客户端插不进去

2 基于udp协议的socket

服务端

msg,client_addr=server.recvfrom(1024) # 前面是信息,后面是客户端地址,例如:b'hello' ('127.0.0.1', 60936)

import socket

lst = {'egon': '\033[1;31m', 'yuan': '\033[1;34m'} #不同的人不同颜色
sk = socket.socket(type=socket.SOCK_DGRAM)
sk.bind(('127.0.0.1', 9090))
while True:
msg, client_addr = sk.recvfrom(1024) # udp协议不用建立链接
name, mesg = msg.decode('utf-8').split(':')
color = lst.get(name.strip(), '')
print('%s%s\033[0m' % (color, msg.decode('utf-8')))
inp = input('>>>')
sk.sendto(inp.encode('utf-8'), client_addr) sk.close()

客户端

import socket

sk = socket.socket(type=socket.SOCK_DGRAM)
name = input('请输入名字: ')
while True:
inp = input('请输入发送内容: ')
sk.sendto(('%s : %s' % (name, inp)).encode('utf-8'), ('127.0.0.1', 9090))
msg, addr = sk.recvfrom(1024)
print(msg.decode('utf-8')) sk.close()

客户端和服务端可以不分先后的开启,udp模式必须先接收信息,因为它必须先要收到地址才能发送信息

3 socket的参数详解

socket.socket(family=AF_INET,type=SOCK_STREAM,proto=0,fileno=None)
创建socket对象的参数说明:
family 地址系列应为AF_INET(默认值),AF_INET6,AF_UNIX,AF_CAN或AF_RDS。
(AF_UNIX 域实际上是使用本地 socket 文件来通信)
type 套接字类型应为SOCK_STREAM(默认值),SOCK_DGRAM,SOCK_RAW或其他SOCK_常量之一。
SOCK_STREAM 是基于TCP的,有保障的(即能保证数据正确传送到对方)面向连接的SOCKET,多用于资料传送。 
SOCK_DGRAM 是基于UDP的,无保障的面向消息的socket,多用于在网络上发广播信息。
proto 协议号通常为零,可以省略,或者在地址族为AF_CAN的情况下,协议应为CAN_RAW或CAN_BCM之一。
fileno 如果指定了fileno,则其他参数将被忽略,导致带有指定文件描述符的套接字返回。
与socket.fromfd()不同,fileno将返回相同的套接字,而不是重复的。
这可能有助于使用socket.close()关闭一个独立的插座。

socketserver

socketserver内部使用io多路复用,以及多线程和多进程,从而实现并发处理多个客户端请求的socket服务端

即:每个客户端请求连接到服务器时,socket服务端都会在服务器端创建一个线程或者进程,负责处理对应的客户端请求

进度条 --- socket  ---socketserver

它的基础使用的时socket

Threading TCPServer实现的是:socket服务器内部为每个client创建一个线程

下面查看一下其内部的部分代码

class BaseRequestHandler:
def __init__(self, request, client_address, server):
self.request = request
self.client_address = client_address
self.server = server
self.setup()
try:
self.handle()
finally:
self.finish()
def setup(self):
pass def handle(self):
pass def finish(self):
pass

所以使用socketserver有其固定的部分

服务端:

import socketserver
class MyServer(socketserver.BaseRequestHandler):
def handle(self):
# print(self.request) server = socketserver.ThreadingTCPServer((ip,port),MyServer)
server.serve_forever()

下面来看其用法:

服务端:

import socketserver
class Myserver(socketserver.BaseRequestHandler):
def handle(self):
while True:
print(self.request)
data=input('>>>').strip()
self.request.send(data.encode('utf-8'))
print(self.request.recv(1024))
if __name__ == '__main__':
server=socketserver.ThreadingTCPServer(('127.0.0.1',9000),Myserver)
server.serve_forever()

客户端

import socket
sk=socket.socket()
sk.connect(('127.0.0.1',9000))
while True:
print(sk.recv(1024))
inp=input('>>>').encode('utf-8')
sk.send(inp)
sk.close()

接下来:先启动服务端,再启动两个客户端   其结果如下:

说明:启动客户端后,再启动一个客户端,服务器先发一条信息,这个客户端接到信息,接着启动第二个客户端

服务端的情况

<socket.socket fd=428, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 49750)>
>>>who
b'client2'
<socket.socket fd=512, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 49753)>
>>>1
b'client1 -1'
<socket.socket fd=428, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 49750)>
>>>1
b''
<socket.socket fd=512, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 49753)>
>>>hehe
b'client'
<socket.socket fd=428, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 49750)>
>>>3
b'haohao'
<socket.socket fd=512, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 49753)>
>>>

result: 信息可以输入的顺序:先服务器输入信息,第一个客户端接收,发送信息,接着回到服务端,服务端再发一条信息,第二个客户端收到,再回到服务端,周而复始。。。

下面演变为:让两个客户端通信,设置为client先发信息,接着client2再发

服务器端:
import socketserver
l=[]
class Myserver(socketserver.BaseRequestHandler):
def handle(self):
l.append(self.request)
print(l)
while True:
data=l[0].recv(1024)
l[1].send(data)
data2=l[1].recv(1024)
l[0].send(data2)
if __name__ == '__main__':
server=socketserver.ThreadingTCPServer(('127.0.0.1',9000),Myserver)
server.serve_forever() 客户端 client
import socket
sk=socket.socket()
sk.connect(('127.0.0.1',9000))
while True:
inp=input('>>>').encode('utf-8')
sk.send(inp)
data=sk.recv(1024).decode('utf-8')
print(data)
sk.close() 客户端 client2
import socket
sk=socket.socket()
sk.connect(('127.0.0.1',9000))
while True:
print(sk.recv(1024).decode('utf-8'))
inp=input('>>>').encode('utf-8')
sk.send(inp)
sk.close()

结果显示:

服务端:
[<socket.socket fd=588, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 50089)>]
[<socket.socket fd=588, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 50089)>, <socket.socket fd=608, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 50091)>] 客户端client
>>>nihao
nihao
>>>你是谁
我是client2
>>>幸会,我这是client 客户端 client2
nihao
>>>nihao
你是谁
>>>我是client2
幸会,我这是client
>>>

 socketserver的最终解释:server可以接收多个客户端,会根据先后顺序记录下面,server端发信息,按照客户端连接的顺序来的.

server -->client

client --->server

server --->client2

client2 --->server

server---->client 。。。。。周而复始