Django框架10 /sweetalert插件、django事务和锁、中间件、django请求生命周期

2023-08-21 22:30:40

Django框架10 /sweetalert插件、django事务和锁、中间件、django请求生命周期

Django框架10 /sweetalert插件、django事务和锁、中间件、django请求生命周期

1. SweetAlert插件示例

使用流程：
1. 在github下载css、js文件放到项目静态文件夹中，https://github.com/LBZHK/bootstrap-sweetalert
2. 在html页面分别引入jquery、bootstrap文件，sweetalert是基于bootstrap实现，bootstrap是基于jquery实现的
3. 将代码复制到script标签中

代码示例：

$(".btn-danger").on("click", function () {

  swal({

    title: "你确定要删除吗？",

    text: "删除可就找不回来了哦！",

    type: "warning",

    showCancelButton: true,

    confirmButtonClass: "btn-danger",

    confirmButtonText: "删除",

    cancelButtonText: "取消",

    closeOnConfirm: false

    },

    function () {

      var deleteId = $(this).parent().parent().attr("data_id");

      // 注意：此处$(this)已经不是".btn-danger"这个点击的对象

      $.ajax({

        url: "/delete_book/",

        type: "post",

        data: {"id": deleteId},

        success: function (data) {

          if (data.status === 1) {

            swal("删除成功!", "你可以准备跑路了！", "success");

          } else {

            swal("删除失败", "你可以再尝试一下！", "error")

          }

        }

      })

    });

})

Django框架10 /sweetalert插件、django事务和锁、中间件、django请求生命周期

2. django事务和锁

mysql

# 锁：

select * from book where id=1 for update;

# 事务：

begin/start trancsation   # 开启事务

	select * from book where id=1 for update;

commit   # 提交

rollback   # 回滚

django orm的事务/锁

锁

models.Book.objects.select_for_update().filter(id=1)

事务

全局开启事务

# 1.在Web应用中，常用的事务处理方式是将每个请求都包裹在一个事务中。这个功能使用起来非常简单，你只需要将它的配置项ATOMIC_REQUESTS设置为True。

# 2.当有请求过来时，Django会在调用视图方法前开启一个事务。如果请求正确处理并正确返回了结果，Django就会提交该事务。否则，Django会自动回滚该事务。

DATABASES = {

    'default': {

        'ENGINE': 'django.db.backends.mysql',

        'NAME': 'mxshop',

        'HOST': '127.0.0.1',

        'PORT': '3306',

        'USER': 'root',

        'PASSWORD': '123',

        'OPTIONS': {

            "init_command": "SET default_storage_engine='INNODB'",

　　　　　　　#'init_command': "SET sql_mode='STRICT_TRANS_TABLES'", # 配置开启严格sql模式

        }

        "ATOMIC_REQUESTS": True,  # 全局开启事务，绑定的是http请求响应整个过程

        "AUTOCOMMIT":False,   # 全局取消自动提交，慎用

    }，

　　'other':{

　　　　'ENGINE': 'django.db.backends.mysql',

            ......

　　}   # 还可以配置其他数据库

}

局部使用事务

用法1：给函数做装饰器来使用

from django.db import transaction

@transaction.atomic

def viewfunc(request):

    # This code executes inside a transaction.

    do_stuff()

用法2：作为上下文管理来使用，其实就是设置事务的保存点

from django.db import transaction

def viewfunc(request):

    # This code executes in autocommit mode (Django's default).

    do_stuff()

    with transaction.atomic():   # 保存点

        # This code executes inside a transaction.

        do_more_stuff()

    do_other_stuff()

3. 中间件

中间件概述

中间件顾名思义，是介于request与response处理之间的一道处理过程，相对比较轻量级，并且在全局上改变django的输入与输出。因为改变的是全局，所以需要谨慎实用，用不好会影响到性能。

django默认自带的一些中间件：

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',

]

# MIDDLEWARE配置项是一个列表，列表中是一个个字符串，这些字符串其实是一个个类，也就是一个个中间件。

自定义中间件

# 中间件可以定义五个方法，分别是：

process_request(self,request)

process_view(self, request, view_func, view_args, view_kwargs)

process_template_response(self,request,response)

process_exception(self, request, exception)

process_response(self, request, response)

# 主要的是process_request和process_response

# 以上方法的返回值可以是None或一个HttpResponse对象，如果是None，则继续按照django定义的规则向后继续执行，如果是HttpResponse对象，则直接将该对象返回给用户。

# 注意：将自定义中间件添加到setting文件中MIDDLEWARE注意顺序

process_request

def process_request(self, request):

    print("MD1里面的 process_request")

# 1.process_request有一个参数，就是request，这个request和视图函数中的request是一样的

# 2.process_request方法里面不写返回值，默认也是返回None，如果写了return None，也是一样的效果，不会中断请求，但是如果return 的一个httpresponse对象，那么就会在这个方法中断请求，直接返回给用户，这就成了非正常的流程了

# 3.如果在这里return了httpresponse对象，那么会从这个中间件类中的process_response方法开始执行返回操作，所以这个类里面只要有process_response方法，肯定会执行

示例代码：

# settings.py的MIDDLEWARE配置项

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',

    'middlewares.MD1',  # 自定义中间件MD1，这个写的是项目路径下的一个路径，

    # 例如，如果放在项目下，文件夹名成为utils，那么这里应该写utils.middlewares.MD1

    'middlewares.MD2'  # 自定义中间件MD2

]

from django.utils.deprecation import MiddlewareMixin

class MD1(MiddlewareMixin):

    def process_request(self, request):

        print("MD1里面的 process_request")

class MD2(MiddlewareMixin):

    def process_request(self, request):

        print("MD2里面的 process_request")

        pass

# 结果：

MD1里面的 process_request

MD2里面的 process_request

app01 中的 index视图

process_response

def process_response(self,request,response):

    return response

# 1.它有两个参数，一个是request，一个是response，request就是上述例子中一样的对象，response是视图函数返回的HttpResponse对象。该方法的返回值也必须是HttpResponse对象

# 2.注意：process_response函数要有return response返回值

示例代码：

from django.utils.deprecation import MiddlewareMixin

from django.shortcuts import HttpResponse

class Md1(MiddlewareMixin):

    def process_request(self,request):

        print("Md1请求")

    def process_response(self,request,response):

        print("Md1返回")

        return response

class Md2(MiddlewareMixin):

    def process_request(self,request):

        print("Md2请求")

        # return HttpResponse("Md2中断")

    def process_response(self,request,response):

        print("Md2返回")

        return response  ****

# 结果：

Md1请求

Md2请求

view函数...

Md2返回

Md1返回

process_view

process_view(self, request, view_func, view_args, view_kwargs)

# Django会在执行完url控制器后，调用视图函数之前调用process_view方法

# 四个参数：

# request是HttpRequest对象。

# view_func是Django即将使用的视图函数/它是实际的函数对象，而不是函数的名称作为字符串。

# view_args是将传递给视图的位置参数的列表.

# view_kwargs是将传递给视图的关键字参数的字典/view_args和view_kwargs都不包含第一个视图参数（request）。

# 可以返回None或一个HttpResponse对象。

# 如果返回None，Django将继续处理这个请求，执行任何其他中间件的process_view方法，然后在执行相应的视图。

# 如果它返回一个HttpResponse对象，Django不会调用对应的视图函数。 它将执行中间件的process_response方法并将应用到该HttpResponse并返回结果。

示例代码：

from django.utils.deprecation import MiddlewareMixin

class MD1(MiddlewareMixin):

    def process_request(self, request):

        print("MD1里面的 process_request")

    def process_response(self, request, response):

        print("MD1里面的 process_response")

        return response

    def process_view(self, request, view_func, view_args, view_kwargs):

        print("-" * 80)

        print("MD1 中的process_view")

        print(view_func, view_func.__name__)

        # 就是url映射到的那个视图函数，也就是说每个中间件的这个process_view已经提前拿到了要执行的那个视图函数

        # ret = view_func(request)  # 提前执行视图函数，不用到了上图的视图函数的位置再执行，如果视图函数有参数的话，可以这么写 view_func(request,view_args,view_kwargs)

        # return ret  # 直接就在MD1中间件这里这个类的process_response给返回了，就不会去找到视图函数里面的这个函数去执行了。

class MD2(MiddlewareMixin):

    def process_request(self, request):

        print("MD2里面的 process_request")

        pass

    def process_response(self, request, response):

        print("MD2里面的 process_response")

        return response

    def process_view(self, request, view_func, view_args, view_kwargs):

        print("-" * 80)

        print("MD2 中的process_view")

        print(view_func, view_func.__name__)

 # 结果：

MD2里面的 process_request

MD1里面的 process_request

-------------------------------------------------------------------------------

MD2 中的process_view

<function index at 0x000001DE68317488> index

-------------------------------------------------------------------------------

MD1 中的process_view

<function index at 0x000001DE68317488> index

app01 中的 index视图

MD1里面的 process_response

MD2里面的 process_response

正常流程图：

Django框架10 /sweetalert插件、django事务和锁、中间件、django请求生命周期

非正常流程图：

Django框架10 /sweetalert插件、django事务和锁、中间件、django请求生命周期

process_exception

process_exception(self, request, exception)

# 两个参数:

# 1.一个HttpRequest对象

# 2.一个exception是视图函数异常产生的Exception对象。

# 这个方法只有在视图函数中出现异常了才执行，它返回的值可以是一个None也可以是一个HttpResponse对象。

# 如果是HttpResponse对象，Django将调用模板和中间件中的process_response方法，并返回给浏览器，否则将默认处理异常。

# 如果返回一个None，则交给下一个中间件的process_exception方法来处理异常。它的执行顺序也是按照中间件注册顺序的倒序执行。

代码示例：

def index(request):

    print("app01 中的 index视图")

    raise ValueError("呵呵")

    return HttpResponse("O98K")

from django.utils.deprecation import MiddlewareMixin

class MD1(MiddlewareMixin):

    def process_request(self, request):

        print("MD1里面的 process_request")

    def process_response(self, request, response):

        print("MD1里面的 process_response")

        return response

    def process_view(self, request, view_func, view_args, view_kwargs):

        print("-" * 80)

        print("MD1 中的process_view")

        print(view_func, view_func.__name__)

    def process_exception(self, request, exception):

        print(exception)

        print("MD1 中的process_exception")

class MD2(MiddlewareMixin):

    def process_request(self, request):

        print("MD2里面的 process_request")

        pass

    def process_response(self, request, response):

        print("MD2里面的 process_response")

        return response

    def process_view(self, request, view_func, view_args, view_kwargs):

        print("-" * 80)

        print("MD2 中的process_view")

        print(view_func, view_func.__name__)

    def process_exception(self, request, exception):

        print(exception)

        print("MD2 中的process_exception")

# 结果：

MD1里面的 process_request

MD2里面的 process_request

--------------------------------------------------------------------------------

MD1 中的process_view

<function index at 0x0000022C09727488> index

--------------------------------------------------------------------------------

MD2 中的process_view

<function index at 0x0000022C09727488> index

app01 中的 index视图

呵呵

MD2 中的process_exception

MD2里面的 process_response

MD1里面的 process_response

# 注意，这里并没有执行MD2的process_exception方法，因为MD1中的process_exception方法直接返回了一个响应对象。

正常流程图：

Django框架10 /sweetalert插件、django事务和锁、中间件、django请求生命周期

非正常流程图：

Django框架10 /sweetalert插件、django事务和锁、中间件、django请求生命周期

process_template_response

process_template_response(self, request, response)

# 参数:

# 1.request是HttpRequest对象

# 2.response是TemplateResponse对象（由视图函数或者中间件产生）。

# process_template_response是在视图函数执行完成后立即执行，但是它有一个前提条件，那就是视图函数返回的对象有一个render()方法（或者表明该对象是一个TemplateResponse对象或等价方法）。

代码示例：

def index(request):

    print("app01 中的 index视图")

　　#raise ValueError('出错啦')

    def render():

        print("in index/render")

        # raise ValueError('出错啦') # 至于render函数中报错了，那么会先执行process_template_response方法，然后执行process_exception方法，如果是在render方法外面报错了，那么就不会执行这个process_template_response方法了。

        return HttpResponse("O98K") # 返回的将是这个新的对象

    	# raise ValueError('出错啦') 将报错放到这个位置不会报错

    rep = HttpResponse("OK")

    rep.render = render

    return rep

cookie认证/中间件版

class M1(MiddlewareMixin):

    def process_request(self,request):

        # 设置路径白名单，只要访问的是login登陆路径，就不做这个cookie认证

        if request.path not in [reverse('login'),]:

            print('我是M1中间件')

            is_login = request.COOKIES.get('is_login', False)

            if is_login:

                pass

            else:

                # return render(request,'login.html')

                return redirect(reverse('login'))

        else:

            return None  # 别忘了return None，或者直接写个pass

    def process_response(self,request,response):

        print('M1响应部分')

        return response

4. 中间件应用/登录认证

view

from django.shortcuts import render,HttpResponse,redirect

def login(request):

    if request.method == 'GET':

        return render(request,'login.html')

    else:

        name = request.POST.get('name')

        password = request.POST.get('password')

        if name == 'liu' and password == '123':

            request.session['is_login'] = True

            return redirect('index')

        else:

            return redirect('login')

def index(request):

    return render(request,'index.html')

mymiddleware.py

from django.utils.deprecation import MiddlewareMixin

from django.shortcuts import HttpResponse,render,redirect

class MD1(MiddlewareMixin):

    white_list = ['/login/']

    def process_request(self,request):

        print('请求来了')

        path = request.path

        if  path not in self.white_list:

            status = request.session.get('is_login')

            if not status:

                return redirect('login')

    def process_response(self,request,response):

        print('响应走了')

        return response

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

</head>

<body>

<h1>登录页面</h1>

<form action="" method="post">

    {% csrf_token %}

用户名：<input type="text" name="name">     <!--input标签记得写name-->

密码：<input type="text" name="password">

<button class="submit">提交</button>

</form>

</body>

<script src="https://cdn.bootcss.com/jquery/3.4.1/jquery.js"></script>

<script></script>

</html>

5. django请求生命周期

流程描述：
1. 在浏览器输入网址后，先经过DNS域名解析，解析出对应的ip
2. 请求到达wsgi，在wsgi封装了socket，按着http协议解包，将请求封装成request对象
3. 到达中间件，按顺序执行每个中间件的request方法
4. 在url控制器中，映射到对应的视图函数
5. 在视图函数中，进行数据库相关操作，以及模板渲染
6. 将视图返回结果，返回到中间件，按倒序执行每个中间件的response方法
7. 将返回结果通过wsgi，按照http协议封装响应数据，返回给浏览器
8. 浏览器收到响应结果，对其进行渲染，展示页面

码农公寓