进度条 --- socket ---socketserver

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

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 。。。。。周而复始