网络编程

一 客户端/服务器架构

1.C/S架构

C/S即：Client与Server ，中文意思：客户端与服务器端架构，这种架构也是从用户层面（也可以是物理层面）来划分的。

这里的客户端一般泛指客户端应用程序EXE，程序需要先安装后，才能运行在用户的电脑上，对用户的电脑操作系统环境依赖较大。

2.B/S架构

B/S即：Browser与Server,中文意思：浏览器端与服务器端架构，这种架构是从用户层面来划分的。

Browser浏览器，其实也是一种Client客户端，只是这个客户端不需要大家去安装什么应用程序，只需在浏览器上通过HTTP请求服务器端相关的资源（网页资源），客户端Browser浏览器就能进行增删改查。

 

3.socket概念

socket是应用层与TCP/IP协议通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

所以，我们无需深入理解tcp/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。

 

4.tcp协议和udp协议

TCP（Transmission Control Protocol）可靠的、面向连接的协议（eg:打电话）、传输效率低全双工通信（发送缓存&接收缓存）、面向字节流。使用TCP的应用：Web浏览器；电子邮件、文件传输程序。

UDP（User Datagram Protocol）不可靠的、无连接的服务，传输效率高（发送前时延小），一对一、一对多、多对一、多对多、面向报文，尽最大努力服务，无拥塞控制。使用UDP的应用：域名系统 (DNS)；视频流；IP语音(VoIP)。

我知道说这些你们也不懂，直接上图。

四.套接字（socket）初使用

基于TCP协议的socket

tcp是基于链接的，必须先启动服务端，然后再启动客户端去链接服务端

客户端：

import socket
sk = socket.socket()
sk.connect(('127.0.0.1',9000))
while True:
    msg = sk.recv(1024)
    if msg == b'q':
        break
    print(msg.decode('utf-8'))
    re_msg = input('>>>')
    sk.send(re_msg.encode('utf-8'))
    if re_msg == 'q':
        break
sk.close()

 

 服务端：

import socket
sk = socket.socket()  # 买手机
# sk.bind(('192.168.16.11',9000))  # 给新买的手机换上一张卡
sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加 测试环境才使用，防止黏包
sk.bind(('127.0.0.1',9000))  # 给新买的手机换上一张卡
sk.listen()           # 开机
while True:
    try:
        conn,addr = sk.accept()   #  等电话
        while True:
            msg = input('>>>')
            conn.send(msg.encode('utf-8'))# 说话
            if msg == 'q': break
            msg = conn.recv(1024)         # 听对方说
            if msg == b'q':break
            print(msg.decode('utf-8'))
        conn.close()                  # 挂电话
    except UnicodeDecodeError:
        pass
sk.close()

基于UDP协议的socket

udp是无链接的，启动服务之后可以直接接受消息，不需要提前建立链接，客户端不需要绑定端口

客户端

import socket
sk = socket.socket(type = socket.SOCK_DGRAM)
while True:
    msg_send = input('>>>')
    sk.sendto(msg_send.encode('utf-8'),('127.0.0.1',9000))
    msg,addr = sk.recvfrom(1024)
    print(msg.decode('utf-8'))
    print('server addr :',addr)

sk.close()

 

服务端：

import socket

sk = socket.socket(type=socket.SOCK_DGRAM)
sk.bind(('127.0.0.1',9000))

while True:
    msg,addr = sk.recvfrom(1024)
    print(addr , msg.decode('utf-8'))
    msg_send = input('>>>')
    sk.sendto(msg_send.encode('utf-8'),addr)
sk.close()

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()关闭一个独立的插座。

 

 

 

 

 

 

 

 

 

黏包现象

 server端：

import socket
sk = socket.socket()
sk.bind(('127.0.0.1',9090))
sk.listen()
conn,addr = sk.accept()
conn.send(b'hello,')
conn.send(b'world')
conn.close()
sk.close()

 client端：

import socket
sk = socket.socket()
sk.connect(('127.0.0.1',9091))
ret1 = sk.recv(2)
print(len(ret1),ret1)#2 b'he'
ret2 = sk.recv(1024)
print(ret2)#b'llo,world'
sk.close()

黏包成因

情况一 发送方的缓存机制

 发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）

情况二 接收方的缓存机制

接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包） 

黏包现象只发生在tcp协议中：

1.从表面上看，黏包问题主要是因为发送方和接收方的缓存机制、tcp协议面向流通信的特点。

2.实际上，主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的

黏包的解决方案

struct模块

该模块可以把一个类型，如数字，转成固定长度的bytes

struct.error: 'i' format requires -2147483648 <= number <= 2147483647 #这个是范围

服务端：

import struct
import socket

sk = socket.socket()
sk.bind(('127.0.0.1',9090))
sk.listen()

conn,addr = sk.accept()
while True:
    s = input('>>>').encode('utf-8')
    pack_num = struct.pack('i',len(s))
    conn.send(pack_num)
    conn.send(s)

conn.close()
sk.close()

 客户端：

import socket
import struct
sk = socket.socket()
sk.connect(('127.0.0.1',9090))

while True:
    pack_num = sk.recv(4)
    num = struct.unpack('i',pack_num)[0]
    ret = sk.recv(num)
    print(ret.decode('utf-8'))
sk.close()

验证客户端链接的合法性

服务端：

import os
import hmac
import socket
def auth(conn):
    msg = os.urandom(32)  # # 生成一个随机的字符串
    conn.send(msg)  # # 发送到client端
    result = hmac.new(secret_key, msg)  # 处理这个随机字符串，得到一个结果
    client_digest = conn.recv(1024)  # 接收client端处理的结果
    if result.hexdigest() == client_digest.decode('utf-8'):
        print('是合法的连接')  # 对比成功可以继续通信
        return True
    else:
        print('不合法的连接')  # 不成功 close
        return False


secret_key = b'alex_sb'
sk = socket.socket()
sk.bind(('127.0.0.1',9000))
sk.listen()
conn,addr = sk.accept()
if auth(conn):
    print(conn.recv(1024))
    # 正常的和client端进行沟通了
    conn.close()
else:
    conn.close()
sk.close()

客户端：

import hmac
import socket
def auth(sk):
    msg = sk.recv(32)
    result = hmac.new(key, msg)
    res = result.hexdigest()
    sk.send(res.encode('utf-8'))

key = b'alex_s'
sk = socket.socket()
sk.connect(('127.0.0.1',9000))
auth(sk)
sk.send(b'upload')
# 进行其他正常的和server端的沟通
sk.close()

socketserver模块

服务端：

import socketserver
# tcp协议的server端就不需要导入socket
class Myserver(socketserver.BaseRequestHandler):
    def handle(self):
        conn = self.request
        while True:
            conn.send(b'hello')
            print(conn.recv(1024))

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:
    ret = sk.recv(1024)
    print(ret)
    sk.send(b'byebye')
sk.close()