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