ORM Transactions and locks

lock

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

Affairs

Enable global affairs

# 当有请求过来时，Django会在调用视图方法前开启一个事务。如果请求正确处理并正确返回了结果，Django就会提交该事务。否则，Django会回滚该事务。
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'mxshop',
        'HOST': '127.0.0.1',
        'PORT': '3306',
        'USER': 'root',
        'PASSWORD': '123',
        "ATOMIC_REQUESTS": True, #全局开启事务，绑定的是http请求响应整个过程
    }，
　　} 

Topical affairs

# 用法一:装饰器, 给函数做装饰器使用
from django.db import transaction

@transacation.atomic
def XX(request):
    pass

# 用法二:作为上下文管理器来使用
from django.db import transaction

def XX(request):
    ....
    with transaction.atomic():
        ....
    # with 下的缩进使用事务
    ....

Middleware

Middleware is interposed between a processing request and response process, relatively lightweight, and global changes in djangoinput and output. Because change is global, it is necessary to be cautious and practical, with good will affect the performance.

Middleware can help us to do some additional work performed before and after view function is executed, it is essentially a custom class, a class defines several methods, Django framework will be to execute at a specific time of the request these methods

# 打开Django项目的Settings.py文件，看到下面的MIDDLEWARE配置项，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',
]

Custom Middleware

Middleware can define five methods:

process_request(self,request)
process_view(self, request, view_func, view_args, view_kwargs)
process_exception(self, request, exception)
process_response(self, request, response)
process_template_response(self,request,response)

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

# 当用户发起请求的时候会依次经过所有的的中间件，这个时候的请求时process_request,最后到达views的函数中，views函数处理后，在依次穿过中间件，这个时候是process_response,最后返回给请求者

Examples

In app01 create a folder utils, create a file namemiddlewares

# 我们可以自己定义一个中间件，我们可以写一个类，但是必须继承MiddlewareMixin
from django.utils.deprecation import MiddlewareMixin

class MD1(MiddlewareMixin):
    #自定义中间件，不是必须要有下面这两个方法，有request方法说明请求来了要处理，有response方法说明响应出去时需要处理，不是非要写这两个方法，如果你没写process_response方法，那么会一层一层的往上找，哪个中间件有process_response方法就将返回对象给哪个中间件
    def process_request(self, request):
        print("MD1里面的 process_request")

    def process_response(self, request, response):
        print("MD1里面的 process_response")
        return response

process_request

process_request has one parameter, the request, the request and view function in the request is the same.

Its return value can be None can also be a HttpResponsetarget. The return value is None, then the normal process to continue to go to the next middleware processing, if it is HttpResponsethe object, Django view function will not be performed, and the corresponding object is returned to the browser.

# 在app01下的utils文件夹下的middlewares.py文件中
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

# 在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
]

# 访问一个视图后
MD1里面的 process_request
MD2里面的 process_request
app01 中的 index视图
# 中间件的process_request方法是在执行视图函数之前执行的。
# 当配置多个中间件时，会按照MIDDLEWARE中的注册顺序，也就是列表的索引值，从前到后依次执行的。
# 不同中间件之间传递的request都是同一个对象

process_response

# 它有两个参数，一个是request，一个是response，request就是上述例子中一样的对象，response是视图函数返回的HttpResponse对象。该方法的返回值也必须是HttpResponse对象。
# 给上述的M1和M2加上process_response方法：
from django.utils.deprecation import MiddlewareMixin


class MD1(MiddlewareMixin):

    def process_request(self, request):
        print("MD1里面的 process_request")
        #不必须写return值
    def process_response(self, request, response):
        #request和response两个参数必须有，名字随便取
        print("MD1里面的 process_response")
        # print(response.__dict__['_container'][0].decode('utf-8')) 
        # 查看响应体里面的内容的方法，或者直接使用response.content也可以看到响应体里面的内容，由于response是个变量，直接点击看源码是看不到的，你打印type(response)发现是HttpResponse对象，查看这个对象的源码就知道有什么方法可以用了。
　　　　 return response  
        # 必须有返回值，写return response  ，这个response就像一个接力棒一样
        # return HttpResponse('瞎搞') ,如果你写了这个，那么你视图返回过来的内容就被它给替代了

class MD2(MiddlewareMixin):
    def process_request(self, request):
        print("MD2里面的 process_request")
        pass

    def process_response(self, request, response):          # request和response两个参数必须要有，名字随便取
        print("MD2里面的 process_response") 
        return response  
        # 必须返回response，不然你上层的中间件就没有拿到httpresponse对象，就会报错

# 访问一个视图后
MD1里面的 process_request
MD2里面的 process_request
app01 中的 index视图
MD2里面的 process_response
MD1里面的 process_response
# 多个中间件中的process_response方法是按照MIDDLEWARE中的注册顺序倒序执行的，也就是说第一个中间件的process_request方法首先执行，而它的process_response方法最后执行，最后一个中间件的process_request方法最后一个执行，它的process_response方法是最先执行。

When the return process_request in HttpResponsean object

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse

class Md1(MiddlewareMixin):

    def process_request(self,request):
        print("Md1请求")
　　　　 #process_request方法里面不写返回值，默认也是返回None，如果你自己写了return None，也是一样的效果，不会中断你的请求，但是如果你return 的一个httpresponse对象，那么就会在这个方法中断你的请求，直接返回给用户，这就成了非正常的流程了
        #并且，如果你在这里return了httpresponse对象，那么会从你这个中间件类中的process_response方法开始执行返回操作，所以这个类里面只要有process_response方法，肯定会执行
        return HttpResponse("Md1中断")
 
    def process_response(self,request,response):
        print("Md1返回")
        return response

class Md2(MiddlewareMixin):

    def process_request(self,request):
        print("Md2请求")
        
    def process_response(self,request,response):
        print("Md2返回")
        return response
# 结果:
Md1请求
Md1返回
# 流程图如下:

By doing Middleware Certification

By adding function decorators too much trouble, so you can use the middleware, if you write a session authentication, you need to customize the middleware on djangothe following comes session middleware. Middleware note placement

class M1(MiddlewareMixin):

    def process_request(self,request):

        #设置路径白名单，只要访问的是login登陆路径，就不做这个cookie认证
        if request.path not in [reverse('login'),]:
            is_login = request.COOKIES.get('is_login')
            if is_login:
                return None
            else:
                # return render(request,'login.html')
                return redirect(reverse('login'))
        else:
            return None #别忘了return None，或者直接写个pass

    def process_response(self,request,response):
        return response

process_view

process_view(self, request, view_func, view_args, view_kwargs)
# request是HttpRequest对象。

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

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

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

# Django会在调用视图函数之前调用process_view方法。

# 它应该返回None或一个HttpResponse对象。 如果返回None，Django将继续处理这个请求，执行任何其他中间件的process_view方法，然后在执行相应的视图。 如果它返回一个HttpResponse对象，Django不会调用对应的视图函数。 它将执行中间件的process_response方法并将应用到该HttpResponse并返回结果。

After process_request process_view method, before process_response, executed before the view function is executed in the order MIDDLEWARE registration order from front to back execution

process_exception

​ process_exception(self, request, exception)

​ 该方法两个参数:

​ 一个HttpRequest对象

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

​ 这个方法只有在视图函数中出现异常了才执行，它返回的值可以是一个None也可以是一个HttpResponse对象。如果是HttpResponse对象，Django将调用模板和中间件中的process_response方法，并返回给浏览器，否则将默认处理异常。如果返回一个None，则交给下一个中间件的process_exception方法来处理异常。它的执行顺序也是按照中间件注册顺序的倒序执行。

中间件的执行流程

​ 请求到达中间件之后，先按照正序执行每个注册中间件的process_reques方法，process_request方法返回的值是None，就依次执行，如果返回的值是HttpResponse对象，不再执行后面的process_request方法，而是执行当前对应中间件的process_response方法，将HttpResponse对象返回给浏览器。也就是说：如果MIDDLEWARE中注册了6个中间件，执行过程中，第3个中间件返回了一个HttpResponse对象，那么第4,5,6中间件的process_request和process_response方法都不执行，顺序执行3,2,1中间件的process_response方法。

​ process_request方法都执行完后，匹配路由，找到要执行的视图函数，先不执行视图函数，先执行中间件中的process_view方法，process_view方法返回None，继续按顺序执行，所有process_view方法执行完后执行视图函数。加入中间件3 的process_view方法返回了HttpResponse对象，则4,5,6的process_view以及视图函数都不执行，直接从最后一个中间件，也就是中间件6的process_response方法开始倒序执行。

​ process_template_response和process_exception两个方法的触发是有条件的，执行顺序也是倒序。总结所有的执行流程如下：