网络编程 ------ 基础

一 . 软件

　　客户端: CS架构 , client --> server

　　浏览器: BS架构 , browser --> server

二 . socket模块

　　socket通常也称作"套接字" , 用于描述IP地址和端口 , 是一个通信链的句柄 , 应用程序通常通过"套接字"向网络发出请求或者应答网络请求.

　　socket起源于Unix , 而Unix/Linux基本哲学之一就是"一切皆文件" , 对于文件用[打开] [读写] [关闭] 模式来操作 . socket就是该模式的一个实现 , socket即是一种特殊的文件 , 一些socket函数就是对其进行的操作

　　socket和file的区别:

　　　　-- file模块是针对某个指定文件进行[打开] [读写] [关闭]

　　　　-- socket模块是针对 服务器端 和 客户端 Socket 进行[打开] [读写] [关闭]

import socket

# 创建服务端socket对象
server = socket.socket()

# 绑定IP和端口
server.bind(('192.168.13.155',8000))

# 后边可以等5个人
server.listen(5)

print('服务端准备开始接收客户端的连接')
# 等待客户端来连接，如果没人来就傻傻的等待。
# conn是客户端和服务端连接的对象(伞)，服务端以后要通过该对象进行收发数据。
# addr是客户端的地址信息。
# #### 阻塞,只有有客户端进行连接，则获取客户端连接然后开始进行通信。
conn,addr = server.accept()

print('已经有人连接上了，客户端信息：',conn,addr)


# 通过对象去获取（王晓东通过伞给我发送的消息）
# 1024表示：服务端通过（伞）获取数据时，一次性最多拿1024字节。
data = conn.recv(1024)
print('已经有人发来消息了',data)


# 服务端通过连接对象（伞）给客户端回复了一个消息。
conn.send(b'stop')

# 与客户端断开连接（放开那把伞）
conn.close()

# 关闭服务端的服务
server.close()

　　服务端和客户端的操作:

import socket

server = socket.socket()

server.bind(("IP地址",端口))

server.listen(服务次数)

while 1:
    conn,addr = server.accept()   # 等待与客户端连接
    
    while 1:
        data = conn.recv(最大字节数 = 1024)
        if data == b"exit":
            break

        result = data + b"任意"
        conn.send(result)     # 返回给客户端的内容
    
    conn.close()

import socket

sk = socket.socket()

sk.connect("服务端IP",服务端端口)

while 1:
    name = input(">>>")
    sk.send(name.encode("utf-8"))   # 传给服务端必须是字节
    
    if name == "exit":
        break

    result = sk.recv(1024)          # 服务端回复给客户端的也是字节
    print(result.decode("utf-8"))

sk.close()

　　总结:

　　　　python3 : send / recv 都是字节

　　　　python2 : send / recv 都是字符串

　　　　服务端 :

　　　　　　accept : 阻塞 , 等待客户端来连接

　　　　　　recv : 阻塞 , 等待客户端发来数据

　　　　客户端 :

　　　　　　connect : 阻塞 ,一直在连接 , 直到连接成功才往下运行其他代码

　　　　　　recv : 阻塞 , 等待服务端发来数据　　　　

 三 . Tcp协议和Udp协议

　　Tcp : 可靠的 , 面向连接的协议 , 传输效率低全双工通信 , 面向字节流 . 使用Tcp的应用 : Web浏览器 , 电子邮件 , 文件传输程序.

　　Udp : 不可靠的 , 无连接的服务 , 传输效率高 , 一对一 , 一对多 , 多对一 , 多对多 , 面向报文 , 尽最大努力服务 , 无阻塞控制 . 使用UDP的应用 : 域名系统(DNS) , 视频流 , IP语音(Volp) . 

四 . 套接字初使用

　　1. 基于TCP协议的socket

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

　　server端 :

import socket
sk = socket.socket()
sk.bind(('127.0.0.1',8898))  #把地址绑定到套接字
sk.listen()          #监听链接
conn,addr = sk.accept() #接受客户端链接
ret = conn.recv(1024)  #接收客户端信息
print(ret)       #打印客户端信息
conn.send(b'hi')        #向客户端发送信息
conn.close()       #关闭客户端套接字
sk.close()        #关闭服务器套接字(可选)

　　client端 :

import socket
sk = socket.socket()           # 创建客户套接字
sk.connect(('127.0.0.1',8898))    # 尝试连接服务器
sk.send(b'hello!')
ret = sk.recv(1024)         # 对话(发送/接收)
print(ret)
sk.close()            # 关闭客户套接字

　　问题 : 在重启服务端时可能会遇到

　

　　解决方法:

#加入一条socket配置，重用ip和端口
import socket
from socket import SOL_SOCKET,SO_REUSEADDR
sk = socket.socket()
sk.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
sk.bind(('127.0.0.1',8898))  #把地址绑定到套接字
sk.listen()          #监听链接
conn,addr = sk.accept() #接受客户端链接
ret = conn.recv(1024)   #接收客户端信息
print(ret)              #打印客户端信息
conn.send(b'hi')        #向客户端发送信息
conn.close()       #关闭客户端套接字
sk.close()        #关闭服务器套接字(可选)

　　2 . 基于UDP协议的socket

　　　　udp是无链接的 , 启动服务之后可以直接接受消息 , 不需要提前建立链接.

　　server端:

import socket
udp_sk = socket.socket(type=socket.SOCK_DGRAM)   #创建一个服务器的套接字
udp_sk.bind(('127.0.0.1',9000))        #绑定服务器套接字
msg,addr = udp_sk.recvfrom(1024)
print(msg)
udp_sk.sendto(b'hi',addr)                 # 对话(接收与发送)
udp_sk.close()                         # 关闭服务器套接字

　　client端:

import socket

ip_port=('127.0.0.1',9000)

udp_sk=socket.socket(type=socket.SOCK_DGRAM)
udp_sk.sendto(b'hello',ip_port)

back_msg,addr=udp_sk.recvfrom(1024)

print(back_msg.decode('utf-8'),addr)

　　QQ聊天:

#_*_coding:utf-8_*_
import socket
ip_port=('127.0.0.1',8081)
udp_server_sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
udp_server_sock.bind(ip_port)

while True:
    qq_msg,addr=udp_server_sock.recvfrom(1024)
    print('来自[%s:%s]的一条消息:33[1;44m%s33[0m' %(addr[0],addr[1],qq_msg.decode('utf-8')))
    back_msg=input('回复消息: ').strip()

    udp_server_sock.sendto(back_msg.encode('utf-8'),addr)

server

#_*_coding:utf-8_*_
import socket
ip_port=('127.0.0.1',8081)
udp_server_sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
udp_server_sock.bind(ip_port)

while True:
    qq_msg,addr=udp_server_sock.recvfrom(1024)
    print('来自[%s:%s]的一条消息:33[1;44m%s33[0m' %(addr[0],addr[1],qq_msg.decode('utf-8')))
    back_msg=input('回复消息: ').strip()

    udp_server_sock.sendto(back_msg.encode('utf-8'),addr)

server

　　时间服务器:

# _*_coding:utf-8_*_
from socket import *
from time import strftime

ip_port = ('127.0.0.1', 9000)
bufsize = 1024

tcp_server = socket(AF_INET, SOCK_DGRAM)
tcp_server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
tcp_server.bind(ip_port)

while True:
    msg, addr = tcp_server.recvfrom(bufsize)
    print('===>', msg)

    if not msg:
        time_fmt = '%Y-%m-%d %X'
    else:
        time_fmt = msg.decode('utf-8')
    back_msg = strftime(time_fmt)

    tcp_server.sendto(back_msg.encode('utf-8'), addr)

tcp_server.close()

server

#_*_coding:utf-8_*_
from socket import *
ip_port=('127.0.0.1',9000)
bufsize=1024

tcp_client=socket(AF_INET,SOCK_DGRAM)

while True:
    msg=input('请输入时间格式(例%Y %m %d)>>: ').strip()
    tcp_client.sendto(msg.encode('utf-8'),ip_port)

    data=tcp_client.recv(bufsize)

client

五 . 黏包

　　同时执行多条命令之后 , 得到的结果很可能只有一部分 , 在执行其他命令的时候又接收到之前执行的另外一部分结果 , 这种现象就是黏包 . 

　　注意 : 只有TCP有黏包现象 , UDP永远不会黏包

　　TCP是面向连接的 , 面向流的 , 提供高可靠性服务 . 

　　收发两端都要有一一承兑的socket . 因此 , 发送端为了将多个发往接收端的包 , 更有效的发到对方 , 使用了优化方法 , 将多次间隔较小且数据量小的数据 , 合并成一个大的数据块 , 然后进行封包 . 

　　1. 发生黏包的两种情况

　　　　情况一 : 发送方的缓存机制

　　　　　　发送端需要等缓冲区满才发送出去 , 造成黏包(发送数据时间间隔很短 , 数据量很小 , 会合到一起 , 产生黏包)

#_*_coding:utf-8_*_
from socket import *
ip_port=('127.0.0.1',8080)

tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)


conn,addr=tcp_socket_server.accept()


data1=conn.recv(10)
data2=conn.recv(10)

print('----->',data1.decode('utf-8'))
print('----->',data2.decode('utf-8'))

conn.close()

服务端

#_*_coding:utf-8_*_
import socket
BUFSIZE=1024
ip_port=('127.0.0.1',8080)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(ip_port)


s.send('hello'.encode('utf-8'))
s.send('egg'.encode('utf-8'))

客户端

　　　　情况二 : 接收方的缓存机制

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

#_*_coding:utf-8_*_
from socket import *
ip_port=('127.0.0.1',8080)

tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)


conn,addr=tcp_socket_server.accept()


data1=conn.recv(2) #一次没有收完整
data2=conn.recv(10)#下次收的时候,会先取旧的数据,然后取新的

print('----->',data1.decode('utf-8'))
print('----->',data2.decode('utf-8'))

conn.close()

#_*_coding:utf-8_*_
import socket
BUFSIZE=1024
ip_port=('127.0.0.1',8080)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(ip_port)


s.send('hello egg'.encode('utf-8'))

　　　　总结 :

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

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

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

六 . 黏包的解决的方案

1. struct模块

import struct


res=struct.pack("i","")

print(res)
print(len(res))


obj=struct.unpack("i",res)
print(obj[0])

"""
结果:
b'xb3xb5Vx07'
4
123123123
"""

　　该模型可以把一个类型转换成固定长度的bytes(固定长度4)

2. subprocess模块

import subprocess

res=subprocess.Popen("dir",
                     shell=True,
                     stderr=subprocess.PIPE,
                     stdout=subprocess.PIPE)


print(res.stdout.read().decode("gbk"))

"""
结果:
 驱动器 C 中的卷是 Windows
 卷的序列号是 A786-D135

 C:UsersAdministratorPycharmProjectsuntitled1基础28day 的目录

2018/09/04  15:50    <DIR>          .
2018/09/04  15:50    <DIR>          ..
2018/09/04  15:50               218 1.py
2018/09/04  14:53                 0 __init__.py
               2 个文件            218 字节
               2 个目录 215,588,208,640 可用字节
"""

3. 使用struct模块解决黏包

　　借助struct模块 , 我们可以知道长度数字可以转换成一个标准大小的4字节数字 . 因袭可以利用这个特点来预先发送长度 . 

发送时	接收时
先发送struct转换好的数据长度4字节	先接受4字节使用struct转换成数字来获取要接收的数据长度
再发送数据	再按照长度接受数据

import socket
import subprocess

server = socket.socket()

server.bind(('127.0.0.1',8008))

server.listen(5)

while True:
    print("server is working.....")
    conn,addr = server.accept()
    # 字节类型
    while True:
        # 针对window系统
        try:
            cmd = conn.recv(1024).decode("utf8") # 阻塞

            if cmd == b'exit':
                break

            res=subprocess.Popen(cmd,
                             shell=True,
                             stderr=subprocess.PIPE,
                             stdout=subprocess.PIPE,
                             )
            # print("stdout",res.stdout.read())
            # print("stderr",res.stderr.read().decode("gbk"))
            out=res.stdout.read()
            err=res.stderr.read()

            print("out响应长度",len(out))
            print("err响应长度",len(err))
            if err:
                 import struct
                 header_pack = struct.pack("i", len(err))
                 conn.send(header_pack)
                 conn.send(err)
            else:
                 #构建报头
                 import struct
                 header_pack=struct.pack("i",len(out))
                 print("header_pack",header_pack)
                 # # 发送报头
                 conn.send(str(len(out)).encode("utf8"))
                 # 发送数据
                 conn.send(out)

        except Exception as e:
            break

    conn.close()

import socket
import struct
sk = socket.socket()

sk.connect(('127.0.0.1',8008))

while 1:
    cmd = input("请输入命令：")
    sk.send(cmd.encode('utf-8')) # 字节
    if cmd=="":
        continue
    if cmd == 'exit':
        break

    header_pack=sk.recv(4)
    data_length=struct.unpack("i",header_pack)[0]
    print("data_length",data_length)

    data_length=int(sk.recv(1024).decode("utf8"))
    print("data_length",data_length)

    recv_data_length=0
    recv_data=b""

    while recv_data_length<data_length:
        data=sk.recv(1024)
        recv_data_length+=len(data)
        recv_data+=data

    print(recv_data.decode("gbk"))

sk.close()

 4. 解决黏包的两种方法

方法一:

import socket
import json

sock = socket.socket()
sock.bind(("121.12.11.11",5555))
sock.listen(5)

while 1:
    print("server is working....")
    conn,addr = sock.accept()
    
    while 1:
        data = conn.recv(1024).decode("utf-8")
        file_info = josn.loads(data)

        # 文件信息
        action = file_info.get("action")
        filename = file_info.get("filename")
        filesize = file_info.get("filesize")

        connsend(b"succes")

        # 接收文件数据
        with open("put/" +filename , "wb") as f:
            recv_data_length = 0
            while recv_data_lengh < filesize:
                data = conn.recv(1024)
                recv_data_length += len(data)
                f.write(data)
                print("文件总大小: %s , 已接收 %s" %(filesize,recv_data_length))
        print("接收成功!")
        break
    
    sock.close()

import socket
import os
import json


sock=socket.socket()
sock.connect(("121.12.11.11",5555))

while 1:
    cmd = ("请输入命令:")
    action,filename = cmd.strip().split(" ")

    file_info = {"action":action,"filename":filename,"filesize":filesize}
    file_info_josn = josn.dumps(file_info).encode("utf-8")
    sock.send(file_info_josn)

    # 确认服务端接收到了文件信息
    code = sock.recv(1024).decode("utf-8")
    if code == "succes":
        # 发送文件数据
        with open("filename","rb") as f:
            for line in f:
                sock.send(line)
    else:
        print("服务器异常!")
    break

sock.close()

方法二:

import struct
import socket
import josn
import hashlib


sock = socket.socket()
sock.bind(("121.21.12.11",5555))
sock.listen(5)

while 1:
    print("server is working...")
    conn,addr = sock.accept()
    
    while 1:
        
        # 接收josn的打包长度
        file_info_length_pack = conn.recv(4)
        file_info_length = struct.unpack("i",file_info_length_pack)[0]

        # 接收josn字符串
        file_info_josn = conn.recv(file_info_length)
        file_info = josn.loads(file_info_josn)

        action=file_info.get("action")
        filename=file_info.get("filename")
        filesize=file_info.get("filesize")

        # 循环接收文件
        md5 = hashlib.md5()
        with open("put/" + filename,"wb") as f:
            recv_data_length = 0

            while recv_data_length < filesize:
                data = conn.recv(1024)
                recv_data_length += len(data)
                f.write()
                
                # md5摘要
                md5.update(data)
                print("文件总大小：%s,已成功接收%s" %(filesize,recv_data_length))
        print("接收成功!")
        conn.send(b"ok")
        
        md5_val = md5.hexdigest()
        client_md5 = conn.recv(1024).decode("utf-8")
        
        if md5_val == client_md5:
            conn.send(b"203")

        else:
            conn.send(b"204")
    
        break
    
    sock.close()

import socket
import os
import json
import struct
import hashlib


sock=socket.socket()
sock.connect(("121.21.12.11",5555))

while 1:
    cmd = input("请输入命令:")
    action , filename = cmd.strip().split(" ")
    filesize = os.patn.getsize(filename)

    file_info = {"action":action,"filename":filename,"filesize":filesize}
    file_info_josn = josn.dumps(file_info).encode("utf-8")

    res = struct.pack("i",len(file_info_josn))
    
    # 发送file_info_josn 的打包长度
    sock.send(res)

    # 发送 file_info_josn字节串
    sock.send(file_info_josn)

    md5 = hashlib.md5()
    # 发送文件数据
    with open(filename,"rb") as f:
        for line in f:
            sock.send(line)
            md5.update(line)
    data = sock.recv(1024)
    md5_val = md5.hexdigest()
    sock.send(md5_val.encode("utf-8"))
    is_val = sock.recv(1024).decode("utf-8")
    
    if is_val == "203":
        print("文件上传成功!")

    else:
        print("文件上传失败!")
    break

sock.close()

七 . 并发编程(socketserver模块)

import socketserver


class Myserver(socketserver.BaseRequestHandler):
    def handle(self):

        # 字节类型
        while 1:

            # 针对window系统
            try:
                print("等待信息")
                data = self.request.recv(1024)  # 阻塞

                # 针对linux
                if len(data) == 0:
                    break

                if data == b'exit':
                    break

                response = data + b'SB'
                self.request.send(response)

            except Exception as e:
                break

        self.request.close()

# 1 创建socket对象 2 self.socket.bind()  3 self.socket.listen(5)
server=socketserver.ForkingUDPServer(("127.0.0.1",8899),Myserver)

server.serve_forever()

import socket

sk = socket.socket()

sk.connect(('127.0.0.1',8899))

while 1:
    name = input(">>>>：")
    sk.send(name.encode('utf-8')) # 字节

    response = sk.recv(1024) # 字节
    print(response.decode('utf-8'))