传输层之TCP与UDP协议

TCP与UDP都是用来规定通信方式的
   通信的时候可以随心所欲的聊  也可以遵循一些协议符合要求的聊
   随心所欲的聊：文字 图片 视频 ....
   遵循一些协议：开头带尊称  首行空两格  只准用官话  不能打情骂俏
  不遵循上述协议的也可以通信  只不过遵循了更合规合法合理

  1.TCP协议(重要)
       三次握手建链接
       1.TCP协议也称为可靠协议(数据不容易丢失)
         造成数据不容易丢失的原因不是因为有双向通道  而是因为有反馈机制
         给对方发消息之后会保留一个副本  直到对方回应消息才会删除  否则在一定的时间内反复发送
        2.洪水攻击
        同一时间有大量的客户端请求建立链接 会导致服务端一直处于SYS_RCVD状态
        3.服务端如何区分客户端建立链接的请求
           可以对请求做唯一标识
        四次挥手断链接
        1.四次不能合并为三次
           因为中间需要确认消息是否发完(TIME_WAIT)

    """
 三次握手和四次挥手也可以看成是小情侣谈恋爱的过程
        三次握手:表白在一起
        四次挥手:决裂要分手
    """   
       
   2.UDP协议
      也被称之为数据报协议  不可靠协议
    早期的QQ使用的是纯生的(没有额外的功能)UDP协议
    现在的QQ自己添加了很多的技术和功能
      使用UDP的原因就是因为很简单 快捷 粗暴  只要指定对方的地址就可以发送消息
      """
      TCP我们可以看成是打电话:双方你侬我侬
      UDP我们可以看成是发短信:只要发了就行 不管对方看不看
      """
      
      

应用层

• 应用层相当于是程序员自己写的应用程序 里面的协议非常的多
• 常见的有：HTTP HTTPS FTP

socket模块

• 如果我们需要编写基于网络基于数据交互的程序 意味着我们需要自己通过代码来控制我们之前所学的OSI七层

• socket类似于操作系统 封装了丑陋复杂的接口提供了简单快捷的接口

• cocket也叫套接字：

  AF_UNIX:基于文字类型的套接字家族(单机) AF_INET:基于网络类型的套接字家族(联网)

socket简介

import socket


"""
以后要养成查看源码编写代码的思路
"""
1.产生一个socket对象并指定采用的通信版本和协议(TCP)
server = socket.socket()  # 括号内不写参数 默认就是TCP协议  family=AF_INET基于网络的套接字 type=SOCK_STREAM流式协议即TCP
2.绑定一个固定的地址(服务端必备的条件)
server.bind(('127.0.0.1', 8080))  # 127.0.0.1为本地回环地址 只有自己的电脑可以访问
3.设立半连接池(暂且忽略)
server.listen(5)
4.等待接客
sock, addr = server.accept()  # return sock, addr  三次握手
print(sock, addr)  # sock就是双向通道 addr就是客户端地址
5.服务客人
data = sock.recv(1024)  # 接收客户端发送过来的消息 1024字节
print(data.decode('utf8'))
sock.send('尊敬的客人 您说什么就是什么 一切按照您的要求来'.encode('utf8'))  # 给客户端发送消息 注意消息必须是bytes类型
6.关闭双向通道
sock.close()  # 四次挥手
7.关闭服务端
server.close()  # 店倒闭了




import socket


1.生成socket对象指定类型和协议
client = socket.socket()
2.通过服务端的地址链接服务端
client.connect(('127.0.0.1', 8080))
3.直接给服务端发送消息
client.send('大爷有钱 把你们店最好的给我叫出来'.encode('utf8'))
4.接收服务端发送过来的消息
data = client.recv(1024)
print(data.decode('utf8'))
5.断开与服务端的链接
client.close()

代码优化

1.聊天内容自定义
        针对消息采用input获取
2.让聊天循环起来
        将聊天的部分用循环包起来
3.用户输入的消息不能为空
        本质其实是两边不能都是recv或者send 一定是一方收一方发 
4.服务端多次重启可能会报错
        Address already in use 主要是mac电脑会报
        方式1:改端口号
        方式2:博客里面代码拷贝即可
5.当客户端异常断开的情况下 如何让服务端继续服务其他客人
        windows服务端会直接报错
  mac服务端会有一段时间反复接收空消息延迟报错	
        异常处理、空消息判断
        

半连接池的概念

server.listen(5)   半连接池

当有多个客户端来链接的情况下 我们可以设置等待数量(不考虑并发问题)
假设服务端只有一个人的情况下

在测试半连接池的时候 可以不用input获取消息 直接把消息写死即可 

粘包现象

1.服务端连续执行三次recv
2.客户端连续执行三次send
问题：服务端一次性接收到了客户端三次消息  该现象称为粘包现象


粘包现象产生的原因
    1.不知道每次的数据到底多大
    2.TCP也称为流式协议：数据像流水一样绵绵不绝没有间隔(TCP会针对数据量较小且发送间隔较短的多条数据一次性合并打包)


避免粘包现象的核心思路\关键点
  如何明确即将接收的数据具体有多大

如何将长度变化的数据全部制作成固定长度的数据

struct模块

import struct

 info = b'hello big baby'
 print(len(info))  # 数据真实的长度(bytes)  14
 res = struct.pack('i', len(info))  # 将数据打包成固定的长度 i是固定的打包模式
 print(len(res))  # 打包之后长度为(bytes)   4           报头

 real_len = struct.unpack('i', res)
 print(real_len)  # (14,)             根据固定长度的报头 解析出真实数据的长度


 desc = b'hello my baby I will take you to play big ball'
 print(len(desc))  # 数据真实的长度(bytes)  46
 res1 = struct.pack('i', len(desc))
 print(len(res1))  # 打包之后长度为(bytes)  4           报头

 real_len1 = struct.unpack('i', res1)
 print(real_len1)  # (46,)              根据固定长度的报头 解析出真实数据的长度



解决黏包问题初次版本
    客户端
        1.将真实数据转成bytes类型并计算长度
        2.利用struct模块将真实长度制作一个固定长度的报头
        3.将固定长度的报头先发送给服务端 服务端只需要在recv括号内填写固定长度的报头数字即可
        4.然后再发送真实数据

    服务端
        1.服务端先接收固定长度的报头
        2.利用struct模块反向解析出真实数据长度
        3.recv接收真实数据长度即可


问题1:struct模块无法打包数据量较大的数据 就算换更大的模式也不行
 res = struct.pack('i', 12313213123)
 print(res)
问题2:报头能否传递更多的信息  比如电影大小 电影名称 电影评价 电影简介

终极解决方案:字典作为报头打包 效果更好 数字更小
 data_dict = {
     'file_name': 'xxx老师教学.avi',
     'file_size': 123132131232342342423423423423432423432,
     'file_info': '内容很精彩 千万不要错过',
     'file_desc': '一代神作 私人珍藏'
 }
 import json
 data_json = json.dumps(data_dict)
 print(len(data_json.encode('utf8')))  # 真实字典的长度  228
 res = struct.pack('i', len(data_json.encode('utf8')))
 print(len(res))


黏包问题终极方案
    客户端 
        1.制作真实数据的信息字典(数据长度、数据简介、数据名称)
        2.利用struct模块制作字典的报头
        3.发送固定长度的报头(解析出来是字典的长度)
        4.发送字典数据
        5.发送真实数据     
    服务端
        1.接收固定长度的字典报头
        2.解析出字典的长度并接收
        3.通过字典获取到真实数据的各项信息
        4.接收真实数据长度

黏包代码实战

import socket
import struct
import json


server = socket.socket()
server.bind(('127.0.0.1', 8081))
server.listen(5)

sock, addr = server.accept()
 1.接收固定长度的字典报头
data_dict_head = sock.recv(4)
 2.根据报头解析出字典数据的长度
data_dict_len = struct.unpack('i', data_dict_head)[0]
 3.接收字典数据
data_dict_bytes = sock.recv(data_dict_len)
data_dict = json.loads(data_dict_bytes)  # 自动解码再反序列化
 4.获取真实数据的各项信息
 total_size = data_dict.get('file_size')
 with open(data_dict.get('file_name'), 'wb') as f:
     f.write(sock.recv(total_size))
接收真实数据的时候 如果数据量非常大 recv括号内直接填写该数据量 不太合适 我们可以每次接收一点点 反正知道总长度
 total_size = data_dict.get('file_size')
 recv_size = 0
 with open(data_dict.get('file_name'), 'wb') as f:
     while recv_size < total_size:
         data = sock.recv(1024)
         f.write(data)
         recv_size += len(data)
         print(recv_size)



import socket
import os
import struct
import json

client = socket.socket()
client.connect(('127.0.0.1', 8081))

'''任何文件都是下列思路 图片 视频 文本 ...'''
 1.获取真实数据大小
file_size = os.path.getsize(r'/Users/jiboyuan/PycharmProjects/day36/xx老师合集.txt')
 2.制作真实数据的字典数据
data_dict = {
    'file_name': '有你好看.txt',
    'file_size': file_size,
    'file_desc': '内容很长 准备好吃喝 我觉得营养快线挺好喝',
    'file_info': '这是我的私人珍藏'
}
 3.制作字典报头
data_dict_bytes = json.dumps(data_dict).encode('utf8')
data_dict_len = struct.pack('i', len(data_dict_bytes))
 4.发送字典报头
client.send(data_dict_len)  # 报头本身也是bytes类型 我们在看的时候用len长度是4
 5.发送字典
client.send(data_dict_bytes)
 6.最后发送真实数据
with open(r'/Users/jiboyuan/PycharmProjects/day36/xx老师合集.txt', 'rb') as f:
    for line in f:  # 一行行发送 和直接一起发效果一样 因为TCP流式协议的特性
        client.send(line)
import time
time.sleep(10)