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")
          }
        }
      })
    });
})

    img

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

    正常流程图：

    非正常流程图：

  • 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方法直接返回了一个响应对象。

    正常流程图：

    非正常流程图：

  • 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

  • login.html

    <!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. 浏览器收到响应结果，对其进行渲染，展示页面
posted @ 2019-10-11 22:00  LBZHK  阅读(143)  评论(0)  编辑  收藏  举报