【一】序列化跟反序列化

# api接口开发，最核心最常见的一个过程就是序列化，所谓序列化就是把数据转换格式，序列化可以分两个阶段：【序列化值的是转换数据格式：序列化，返序列化】# 序列化： 把我们识别的数据转换成指定的格式提供给别人
# 序列化： 表模型对象 ---> json格式字符串--->给前端python后端：把python的对象【字典，列表，对象】---》转成json/xml格式字符串过程称之为序列化例如：我们在django中获取到的数据默认是模型对象(qs/单个对象)，但是模型对象数据无法直接提供给前端或别的平台使用，所以我们需要把数据进行序列化，变成字符串或者json数据，提供给别人。# 反序列化：把别人提供的数据转换/还原成我们需要的格式。
# 反序列化： json字符串--->保存到数据库例如：前端js提供过来的json/xml数据，对于python而言就是字符串，我们需要进行反序列化换成模型类对象，这样我们才能把数据保存到数据库中# js 如何把对象序列化成字符串：【JSON.stringify()】，把字符串饭序列化成对象：【JSON.parse()】

【1】序列化（Serialization）

​ 序列化是将对象转换为字节流或其他格式的过程。这通常涉及将对象的状态转换为可以存储或传输的格式，例如字节流、JSON、XML等。序列化的目的是将对象持久化，以便将其保存到文件中、通过网络发送给其他系统或在内存中进行传输。

​ 在序列化过程中，对象的属性值被提取，并根据指定的格式转换为序列化后的表示形式。在Java中，常用的序列化技术是Java序列化（Java Serialization）或JSON序列化（使用类库如Jackson或Gson），而在其他语言中也有类似的序列化技术。

【2】反序列化（Deserialization）：

​ 反序列化是序列化的逆过程，即将序列化后的数据重新转换为对象的过程。在反序列化过程中，从序列化后的数据中提取信息，并根据原始对象的类定义重新构建对象，使其恢复到原始对象的状态。

​ 反序列化的目的是从序列化后的数据中重新创建对象，以便对其进行操作或在程序中使用。与序列化类似，反序列化也是在存储、通信或对象传输等场景中常见的操作。

小结

​ 总的来说，序列化和反序列化是在计算机中用于对象持久化、数据传输和通信的重要概念，它们允许将对象转换为字节流或其他格式，并在需要时重新构建对象。

具体示例

class TaskView(View):def post(self, request):# body gen body的使用方法print(request.body)ta = request.bodyda = json.loads(ta)

import pickle# 定义一个对象
class Person:def __init__(self, name, age):self.name = nameself.age = age# 创建一个 Person 对象
person = Person("Alice", 30)# 序列化对象到文件
with open("person.pickle", "wb") as file:pickle.dump(person, file)# 从文件中反序列化对象
with open("person.pickle", "rb") as file:loaded_person = pickle.load(file)# 打印反序列化后的对象属性
print("Name:", loaded_person.name)
print("Age:", loaded_person.age)

【二】FBV跟CBV的区别

FBV（Function-Based Views）和CBV（Class-Based Views）是两种不同的视图编写方式，它们有一些区别：

1. 实现方式：
   • FBV（Function-Based Views）： 使用函数来编写视图。每个视图是一个独立的函数，接收HTTP请求并返回HTTP响应。
   • CBV（Class-Based Views）： 使用类来编写视图。每个视图是一个类，它可以包含多个方法来处理不同的HTTP请求方法（如GET、POST等）。
2. 代码复用：
   • FBV： 函数的复用性较差，通常需要将相同的代码复制粘贴到不同的视图函数中。
   • CBV： 类的继承机制使得代码的复用性更好。你可以创建一个通用的基类视图，并在不同的子类视图中重写或添加特定的方法。
3. 代码结构：
   • FBV： 每个视图通常都是一个独立的函数，因此在文件中可能会有多个视图函数，使得文件结构较为扁平。
   • CBV： 视图通常是一个类，因此在文件中可能会有多个视图类，使得文件结构更加模块化和组织化。
4. 学习曲线：
   • FBV： 对于初学者来说，函数式视图可能更容易理解和上手，因为它们更接近于普通的Python函数。
   • CBV： 对于复杂的应用程序和视图逻辑，类视图提供了更多的结构化和组织化，但也需要一定的学习曲线。

​ 总的来说，FBV适用于简单的视图逻辑和快速开发，而CBV适用于需要更多结构化和可扩展性的项目。选择使用哪种视图方式取决于你的项目需求和个人偏好。

【三】

【1】FBV的接口具体示例

限制条件

• 1 django —》创建表 Task 任务表

  • -id
    -task_id：唯一，不要用id自增–》时间戳/uuid python 中如何生成uuid 唯一(unique=True)
    -task_name:任务名 建立索引 （index=True）
    -task_time：任务执行时间
    -task_desc:任务描述

• 2 使用mysql

• 3 写 5个 接口

  • 查询所有，查询单个，新增一个，删除一个，修改一个

'''http://127.0.0.1:8000/task/add --->增加一个记录--》post请求方式http://127.0.0.1:8000/task/get/id--->查询这条记录-——》get请求方式http://127.0.0.1:8000/task/update/id--->更新这条记录》post请求方式http://127.0.0.1:8000/task/delete/id--->删除---》post请求方式http://127.0.0.1:8000/task/get/--->查询所有记录-——》get请求方式 '''

• 4 使用requests模块，发送请求实现功能

  ''' -单线程
  -使用多线程 并发 增加记录Thread '''
  

1.路由层

from django.contrib import admin
from django.urls import path
from Api01 import viewsapp_name = 'Api01'urlpatterns = [path('admin/', admin.site.urls),path('task/add/', views.add_task, name='add_task'),path('task/get/<str:id>', views.get_task, name='get_task'),path('task/update/<str:id>', views.update_task, name='update_task'),path('task/delete/<int:id>', views.delete_task, name='delete_task'),path('task/get/', views.get_all_tasks, name='get_all_tasks'),path('add/', views.add),
]

2.视图层

from django.shortcuts import render, HttpResponse, redirect
from django.http import JsonResponse
from Api01.models import Task# 添加任务
def add_task(request):if request.method == 'POST':try:task_id = request.POST.get('task_id')task_name = request.POST.get('task_name')task_time = request.POST.get('task_time')task_desc = request.POST.get('task_desc')Task.objects.create(task_desc=task_desc,task_time=task_time,task_name=task_name,task_id=task_id)return JsonResponse({'code': 100, 'msg': '创建成功'})except Exception as e:return JsonResponse({'code': 200, 'msg': '创建失败，错误信息：{}'.format(str(e))})else:return JsonResponse({'code': 200, 'msg': '请求方法错误'})# 更改任务
# views.pydef get_task(request, id):try:task = Task.objects.get(id=id)result = {'task_id': task.task_id,'task_name': task.task_name,'task_time': task.task_time.strftime('%Y-%m-%d'),'task_desc': task.task_desc}return JsonResponse({'code': 100, 'msg': '查询成功', 'result': result})except Task.DoesNotExist:return JsonResponse({'code': 200, 'msg': '任务记录不存在'})def add(requst):return render(requst, 'succeess.html')# 更新一条任务记录
# views.pydef update_task(request, id):if request.method == 'POST':try:task_name = request.POST.get('task_name')task_time = request.POST.get('task_time')task_desc = request.POST.get('task_desc')Task.objects.filter(pk=id).update(task_desc=task_desc,task_time=task_time,task_name=task_name)return JsonResponse({'code': 100, 'msg': '更新成功'})except Task.DoesNotExist:return JsonResponse({'code': 200, 'msg': '任务记录不存在'})except Exception as e:return JsonResponse({'code': 200, 'msg': '更新失败，错误信息：{}'.format(str(e))})else:return JsonResponse({'code': 200, 'msg': '请求方法错误'})# 删除一条任务记录
# views.pydef delete_task(request, id):if request.method == 'POST':try:task = Task.objects.get(id=id)task.delete()return JsonResponse({'code': 100, 'msg': '删除成功'})except Task.DoesNotExist:return JsonResponse({'code': 200, 'msg': '任务记录不存在'})except Exception as e:return JsonResponse({'code': 200, 'msg': '删除失败，错误信息：{}'.format(str(e))})else:return JsonResponse({'code': 200, 'msg': '请求方法错误'})# 查询所有任务记录
def get_all_tasks(request):tasks = Task.objects.all()results = []for task in tasks:result = {'task_id': task.task_id,'task_name': task.task_name,'task_time': task.task_time.strftime('%Y-%m-%d'),'task_desc': task.task_desc}results.append(result)return JsonResponse({'code': 100, 'msg': '查询成功', 'results': results})def delete(request,id):if request.method == 'POST':# 创建任务记录Task.objects.filter(id = int(id)).delete()return JsonResponse({'code': 100, 'msg': '创建成功'})

3.创建一个test测试接口文件

import random
import string
import threading
from threading import Thread
import time
import uuidimport requests
from fake_useragent import UserAgent
import os
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'three.settings')import django
django.setup()headers = {'User-Agent': UserAgent().random,
}base_url = 'http://127.0.0.1:8000/task/'from datetime import date
from Api01.models import Task  # 导入你的Task模型# 创建多个Task对象并保存到数据库
def add_tasks(task_name,task_desc):data = {"task_name": task_name,"task_desc": task_desc,"task_time": time.strftime('%Y-%m-%d'),"task_id":uuid.uuid1()  # 转换为字符串}url = "http://127.0.0.1:8000/task/add/"  # 请替换为你的服务器地址# 设置请求头response = requests.post(url=url, data =data)print(response.json())def teadinfg(num_data):data_list = []for i in range(1,num_data + 1):task_name = f'Task {i}'task_desc = f'Task {i}'data = Thread(target=add_tasks,args=(task_name,task_desc))data_list.append(data)data.start()for data in data_list:data.join()teadinfg(50)# 查询
def get(id):url = base_url + f'get/{id}'response = requests.get(url=url, headers=headers)# print(response.text)print(response.json())
# get('6')# 查询全部
def get_all():url = base_url + 'get/'response = requests.get(url=url, headers=headers)for info in response.json().get('results'):print(info)# get_all()
# 增加
def add():task_name = input('task_name:>>>').strip()task_desc = input('task_desc:>>>').strip()data = {"task_name": task_name,"task_desc": task_desc,"task_time": time.strftime('%Y-%m-%d'),"task_id":uuid.uuid4()  # 转换为字符串}url = "http://127.0.0.1:8000/task/add/"  # 请替换为你的服务器地址# 设置请求头response = requests.post(url=url, data =data)print(response.json())# add()# 更新指定任务
def update(id):task_name = input('任务名称:>>>>').strip()task_time = time.strftime("%Y-%m-%d")task_desc = input('任务内容:>>>>').strip()data = {'task_name':task_name,'task_time':task_time,'task_desc':task_desc,}url = base_url + f'update/{id}'response = requests.post(url=url,headers=headers,data=data)# print(response.text)print(response.json())# update('6')
# 删除指定任务
def delete(id):url = base_url + f'delete/{id}'response = requests.post(url=url, headers=headers)print(response.json())# delete(12)

【2】CBV的接口具体示例

1.先创建一个UserLog表

class UserLog(models.Model):ip = models.CharField(max_length=100)time = models.DateTimeField(auto_now_add=True)method = models.CharField(max_length=10)path = models.CharField(max_length=255)user_agent = models.CharField(max_length=255)def __str__(self):return f"IP: {self.ip}, Time: {self.time}, Method: {self.method}, Path: {self.path}, User Agent: {self.user_agent}"class Meta:db_table = 'UserLog'

2.在创建一个路由分发

from django.contrib import admin
from django.urls import path,includeurlpatterns = [path('admin/', admin.site.urls),path('task_api/', include('task_api.urls')),
]

3.在子路由写一个正则表达式

from django.urls import path,include,re_path
from task_api.views import TaskViewurlpatterns = [re_path(r'(?P<id>\d+)?/?$', TaskView.as_view()),
]

• (?P<id>\d+): 这是一个命名捕获组，使用 (?P<name>pattern) 的语法，其中 name 是捕获组的名称，pattern 是要匹配的模式。在这里，捕获组的名称是 id，它用于捕获一个或多个数字（\d+）。
• ?: 这个问号表示前面的模式是可选的。换句话说，这个模式要么出现一次，要么不出现。
• /?: 这表示匹配零个或一个斜杠 /。问号 ? 表示前面的斜杠是可选的。
• $: 这个美元符号表示匹配字符串的结尾。

4.在视图层定义CBV

import json
from django.http import JsonResponse
from django.views import View
from .models import Task
import time
import uuidclass TaskView(View):def post(self, request):# body gen body的使用方法# print(request.body)# ta = request.body# da = json.loads(ta)task_name = request.POST.get('task_name')task_desc = request.POST.get('task_desc')task_time = time.strftime('%Y-%m-%d')task_id = uuid.uuid4()# 保存任务到数据库Task.objects.create(task_name=task_name,task_desc=task_desc,task_time=task_time,task_id=task_id)return JsonResponse({'message': 'Task 添加成功！'})def get(self, request, id=None):if id:try:task = Task.objects.get(id=id)print(task)data = {'task_name': task.task_name,'task_desc': task.task_desc,'task_time': task.task_time,'task_id': task.task_id}print(data)return JsonResponse(data)except Task.DoesNotExist:return JsonResponse({'error': 'Task 未能发现数据'}, status=404)else:tasks = Task.objects.all()data = [{'task_name': task.task_name, 'task_desc': task.task_desc, 'task_time': task.task_time, 'task_id': task.task_id} for task in tasks]return JsonResponse({'results': data})def put(self, request, id):try:print(request.body)data = request.bodycalssdatda = json.loads(data)print(calssdatda)print(type(calssdatda))# <class 'dict'>task = Task.objects.get(id=id)print(task)task_name = calssdatda.get('task_name')print(task_name)task_desc = calssdatda.get('task_desc')task_time = time.strftime('%Y-%m-%d')# 更新任务信息task.task_name = task_nametask.task_desc = task_desctask.task_time = task_timetask.save()return JsonResponse({'message': 'Task 更新成功'})except Task.DoesNotExist:return JsonResponse({'error': '未找到数据'}, status=404)def delete(self,request,id):try:Task.objects.filter(pk=id).delete()return JsonResponse({'message': 'Task 删除成功'})except Task.DoesNotExist:return JsonResponse({'error': '未找到数据'}, status=404)

5.写一个中间件进行预处理

from django.utils.deprecation import MiddlewareMixinfrom task_api.models import UserLog
class LogMiddleware(MiddlewareMixin):def process_request(self, request):# 获取请求相关信息# 通过访问 request.META 字典，获取了请求的客户端 IP 地址。'REMOTE_ADDR'# 是一个 HTTP 头的键，它存储了客户端的 IP 地址。这个 IP 地址可以用来识别请求的来源。ip = request.META.get('REMOTE_ADDR')print( request.META)# 获取了请求的方法method = request.method# 获取了请求的路径。request.get_full_path() 方法返回了当前请求的完整路径，包括查询参数（如果有）。path = request.get_full_path()# 获取了客户端的用户代理（User-Agent）。用户代理是一个字符串，用于标识客户端浏览器或其他用户代理程序的信息，如浏览器类型、版本号等。user_agent = request.META.get('HTTP_USER_AGENT')# 将信息记录到数据库中UserLog.objects.create(ip=ip, method=method, path=path, user_agent=user_agent)

6.settings.py进行

• 添加’task_api.middleware.LogMiddleware',ALLOWED_HOSTS = ["*"]

ALLOWED_HOSTS = ["*"]MIDDLEWARE = ['django.middleware.security.SecurityMiddleware','django.contrib.sessions.middleware.SessionMiddleware','django.middleware.common.CommonMiddleware',# 'django.middleware.csrf.CsrfViewMiddleware','django.contrib.auth.middleware.AuthenticationMiddleware','django.contrib.messages.middleware.MessageMiddleware','django.middleware.clickjacking.XFrameOptionsMiddleware','task_api.middleware.LogMiddleware',
]

7.别人访问你的ip地址

• 先打开cmd

• # ipconfig
  

• 在检查本地防火墙是否打开

• 

这些只是准备工作