django---django-cors-headers跨域源码分析

最新推荐文章于 2024-08-25 19:01:30 发布
最新推荐文章于 2024-08-25 19:01:30 发布
阅读量6.6k 收藏 18
点赞数 1
分类专栏： pythonweb框架源码 Django/Flask源码剖析 文章标签： django-cors-headers django cors
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013210620/article/details/80020426
版权

库配置

这篇笔记，是关于跨越的 django—CORS跨域

今天我们来学习下一个开源库django-cors-headers

github上有详细的配置文档说明

1、Install from pip:

pip install django-cors-headers

2、and then add it to your installed apps:

INSTALLED_APPS = (
    ...
    'corsheaders',
    ...
)

3、You will also need to add a middleware class to listen in on responses:

MIDDLEWARE = [  # Or MIDDLEWARE_CLASSES on Django < 1.10
    ...
    'corsheaders.middleware.CorsMiddleware',
    'django.middleware.common.CommonMiddleware',
    ...
]

CORSMIDID餐具应尽可能高的放置，尤其是在任何能产生响应的中间件之前，比如Django的通用中间件或白化的白皮书。如果不是以前，它将无法向这些响应添加CORS头。

此外，如果使用CLSYRePaseHTTPSY引用器，它应该放在Django的CSRFIEWVIEW中间件之前

4、在Django设置中配置中间件的行为。必须将允许跨站点请求的主机添加到CLSIOrthPosixWalelistor，或者将CLSSOrthPosialApple全部设置为true，以允许所有主机。

CORS_ORIGIN_ALLOW_ALL = True

5、另外还有一些白名单、正则url配置，我这里就省略了，我就直接CORS_ORIGIN_ALLOW_ALL = True

示例展示

我接下来利用一个示例，来展示下功能效果
项目配置：


INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'api.apps.ApiConfig',
    'rest_framework',
    'corsheaders',
]

from corsheaders.middleware import CorsMiddleware

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'corsheaders.middleware.CorsMiddleware',
    'django.middleware.common.CommonMiddleware',

    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

CORS_ORIGIN_ALLOW_ALL = True

vue前端代码
contentType: “application/json”发送j’son数据

     doLogin() {
        var _this = this
        $.ajax({
          url: "http://127.0.0.1:8000/api/login/",
          type: 'post',
          data: JSON.stringify({
            "username": this.username,
            "password": this.password,
          }),
          dataType: 'json',
          contentType: "application/json",

          // headers: {
          //   "Content-Type": 'application/json',
          // },
          success: function (newAllDatas) {
            console.info(newAllDatas, "~~~~~~newAllDatas~~~~~~~~")

            if (newAllDatas.data.token) {
              _this.$store.commit('saveToken', {username: newAllDatas.data.username, token: newAllDatas.data.token})
              _this.$router.push({name: 'index'})
            } else {
              _this.error = '用户名或密码错误'
            }
          }
        })
      }

后端api

class LoginView(APIView):
    def generate_key(self,account):
        """根据用户名和时间生成唯一标识"""
        username = account.username
        now = str(datetime.datetime.now()).encode('utf-8')
        md5 = hashlib.md5(username.encode('utf-8'))
        md5.update(now)
        return md5.hexdigest()

    # def options(self, request, *args, **kwargs):
    #     print('进行预检')
    #     obj = HttpResponse()
    #     # obj['Access-Control-Allow-Headers'] = 'Content-Type'
    #     # obj['Access-Control-Allow-Origin'] = '*'
    #     return obj



    def post(self,request,*args,**kwargs):
        try:
            response = BaseResponse()

            with transaction.atomic():
                print(request.data,"request,data")
                print(request._request.POST,"request,POST")

                account = Account.objects.create(username=request.data.get("username"),password=request.data.get("password"))
                if account:
                    token = self.generate_key(account)
                    u_token = UserAuthToken.objects.create(user=account,token=token,created=datetime.datetime.now())
                    if u_token:

                        usdata = UserSerializer(instance=account)

                        response.data = usdata.data
                        response.error = "1000"
                        response.msg = "登录成功"

                        ret = Response(response.dict)
                        # ret['Access-Control-Allow-Origin'] = '*'
                        print("[response.dict]", response.dict)
                        return ret

        except IndexError as e:
            response.error = "2000"
            response.msg = "登录失败"
            ret = Response(response.dict)
            # ret['Access-Control-Allow-Origin'] = '*'
            print("[Exception type %s][response.dict%s]"%(str(e),response.dict))
            return ret

这里写图片描述

源码分析

我先贴出来该开源库的目录结构
这里写图片描述

在该库的__init__.py模块下from .checks import check_settings导入该模块
在checks.py中经过@checks.register进行装饰过滤，主要是判断我们的配置有没有问题，例如
我们之前在配置文件中进行的配置CORS_ORIGIN_ALLOW_ALL = True，是否是bool类型的

 if not isinstance(conf.CORS_ORIGIN_ALLOW_ALL, bool):
        errors.append(
            checks.Error(
                "CORS_ORIGIN_ALLOW_ALL should be a bool.",
                id="corsheaders.E005"
            )
        )

该checks.py模块头部，还引入from .conf import conf，我们看看这个配置是做什么处理工作的？
我这里就列举出来，该类中的某些方法，我们依然拿CORS_ORIGIN_ALLOW_ALL = True举例，该类的主要左用就是通过反射作用，获取配置的值

class Settings(object):
      @property
    def CORS_ORIGIN_ALLOW_ALL(self):
        return getattr(settings, 'CORS_ORIGIN_ALLOW_ALL', False)

conf.py模块中，头部引入了from .defaults import default_headers, default_methods
是对请求头、及其请求方式做了列举

default_headers = (
    'accept',
    'accept-encoding',
    'authorization',
    'content-type',
    'dnt',
    'origin',
    'user-agent',
    'x-csrftoken',
    'x-requested-with',
)

default_methods = (
    'DELETE',
    'GET',
    'OPTIONS',
    'PATCH',
    'POST',
    'PUT',
)

我们接下来就看下middleware.py如何实现跨域的

还记得我们在配置中配置的中间件么

'corsheaders.middleware.CorsMiddleware'

代码不多，我就直接贴出来了

class CorsMiddleware(MiddlewareMixin):

    def _https_referer_replace(self, request):
        """
        When https is enabled, django CSRF checking includes referer checking
        which breaks when using CORS. This function updates the HTTP_REFERER
        header to make sure it matches HTTP_HOST, provided that our cors logic
        succeeds
        """
        origin = request.META.get('HTTP_ORIGIN')

        if request.is_secure() and origin and 'ORIGINAL_HTTP_REFERER' not in request.META:

            url = urlparse(origin)
            if not conf.CORS_ORIGIN_ALLOW_ALL and not self.origin_found_in_white_lists(origin, url):
                return

            try:
                http_referer = request.META['HTTP_REFERER']
                http_host = "https://%s/" % request.META['HTTP_HOST']
                request.META = request.META.copy()
                request.META['ORIGINAL_HTTP_REFERER'] = http_referer
                request.META['HTTP_REFERER'] = http_host
            except KeyError:
                pass

    def process_request(self, request):
        """
        If CORS preflight header, then create an
        empty body response (200 OK) and return it

        Django won't bother calling any other request
        view/exception middleware along with the requested view;
        it will call any response middlewares
        """
        request._cors_enabled = self.is_enabled(request)
        if request._cors_enabled:
            if conf.CORS_REPLACE_HTTPS_REFERER:
                self._https_referer_replace(request)

            if (
                request.method == 'OPTIONS' and
                'HTTP_ACCESS_CONTROL_REQUEST_METHOD' in request.META
            ):
                return http.HttpResponse()

    def process_view(self, request, callback, callback_args, callback_kwargs):
        """
        Do the referer replacement here as well
        """
        if request._cors_enabled and conf.CORS_REPLACE_HTTPS_REFERER:
            self._https_referer_replace(request)
        return None

    def process_response(self, request, response):
        """
        Add the respective CORS headers
        """
        origin = request.META.get('HTTP_ORIGIN')
        if not origin:
            return response

        enabled = getattr(request, '_cors_enabled', None)
        if enabled is None:
            enabled = self.is_enabled(request)

        if not enabled:
            return response

        # todo: check hostname from db instead
        url = urlparse(origin)

        if conf.CORS_ALLOW_CREDENTIALS:
            response[ACCESS_CONTROL_ALLOW_CREDENTIALS] = 'true'

        if (
            not conf.CORS_ORIGIN_ALLOW_ALL and
            not self.origin_found_in_white_lists(origin, url) and
            not self.origin_found_in_model(url) and
            not self.check_signal(request)
        ):
            return response

        if conf.CORS_ORIGIN_ALLOW_ALL and not conf.CORS_ALLOW_CREDENTIALS:
            response[ACCESS_CONTROL_ALLOW_ORIGIN] = "*"
        else:
            response[ACCESS_CONTROL_ALLOW_ORIGIN] = origin
            patch_vary_headers(response, ['Origin'])

        if len(conf.CORS_EXPOSE_HEADERS):
            response[ACCESS_CONTROL_EXPOSE_HEADERS] = ', '.join(conf.CORS_EXPOSE_HEADERS)

        if request.method == 'OPTIONS':
            response[ACCESS_CONTROL_ALLOW_HEADERS] = ', '.join(conf.CORS_ALLOW_HEADERS)
            response[ACCESS_CONTROL_ALLOW_METHODS] = ', '.join(conf.CORS_ALLOW_METHODS)
            if conf.CORS_PREFLIGHT_MAX_AGE:
                response[ACCESS_CONTROL_MAX_AGE] = conf.CORS_PREFLIGHT_MAX_AGE

        return response

    def origin_found_in_white_lists(self, origin, url):
        return (
            url.netloc in conf.CORS_ORIGIN_WHITELIST or
            (origin == 'null' and origin in conf.CORS_ORIGIN_WHITELIST) or
            self.regex_domain_match(origin)
        )

    def regex_domain_match(self, origin):
        for domain_pattern in conf.CORS_ORIGIN_REGEX_WHITELIST:
            if re.match(domain_pattern, origin):
                return origin

    def origin_found_in_model(self, url):
        if conf.CORS_MODEL is None:
            return False
        model = apps.get_model(*conf.CORS_MODEL.split('.'))
        return model.objects.filter(cors=url.netloc).exists()

    def is_enabled(self, request):
        return (
            bool(re.match(conf.CORS_URLS_REGEX, request.path)) or
            self.check_signal(request)
        )

    def check_signal(self, request):
        signal_responses = check_request_enabled.send(
            sender=None,
            request=request,
        )
        return any(
            return_value for
            function, return_value in signal_responses
        )

我们就简单分析下即可
先经过process_request，先看下这个类方法

   def process_request(self, request):
        """
        If CORS preflight header, then create an
        empty body response (200 OK) and return it

        Django won't bother calling any other request
        view/exception middleware along with the requested view;
        it will call any response middlewares
        """
        request._cors_enabled = self.is_enabled(request)
        if request._cors_enabled:
            if conf.CORS_REPLACE_HTTPS_REFERER:
                self._https_referer_replace(request)

            if (
                request.method == 'OPTIONS' and
                'HTTP_ACCESS_CONTROL_REQUEST_METHOD' in request.META
            ):
                return http.HttpResponse()

process_request代码意思就是通过is_enabled方法，通过request.path进行正则判断是否是可用的url,
然后通过 conf.CORS_REPLACE_HTTPS_REFERER（默认falsel），来进行解决CSRFYtrutrudDoad源文图，
ps如下：
在Jjango 1.9中引入了CSRFYtrutrudDoad源，因此早期版本的用户需要一个替代的解决方案。如果COSYRePaseJTHPSPSJORKER是真的，CORSMIDIDWORKES会将引用头更改为当CORS检查通过时将通过Django的CSRF检查的东西。默认为false。

然后判断如下代码，当请求添加自定义头部，或者contentType为json（复杂请求），会执行OPTIONS，我们需要预检信息

 if (
                request.method == 'OPTIONS' and
                'HTTP_ACCESS_CONTROL_REQUEST_METHOD' in request.META
            ):
                return http.HttpResponse()

然后直接进入该中间件的process_response，在该方法里面，也就是进行了具体的跨域处理
跨域传输cookie如下

 if conf.CORS_ALLOW_CREDENTIALS:
            response[ACCESS_CONTROL_ALLOW_CREDENTIALS] = 'true'

允许不同源的链接访问

  if conf.CORS_ORIGIN_ALLOW_ALL and not conf.CORS_ALLOW_CREDENTIALS:
            response[ACCESS_CONTROL_ALLOW_ORIGIN] = "*"
        else:
            response[ACCESS_CONTROL_ALLOW_ORIGIN] = origin
            patch_vary_headers(response, ['Origin'])

OPTIONS进行预检

 if request.method == 'OPTIONS':
            response[ACCESS_CONTROL_ALLOW_HEADERS] = ', '.join(conf.CORS_ALLOW_HEADERS)
            response[ACCESS_CONTROL_ALLOW_METHODS] = ', '.join(conf.CORS_ALLOW_METHODS)
            if conf.CORS_PREFLIGHT_MAX_AGE:
                response[ACCESS_CONTROL_MAX_AGE] = conf.CORS_PREFLIGHT_MAX_AGE

以上就是基本的源码分析

易辰_
关注
专栏目录
Django-cors-headers解决跨域请求
菲宇运维
06-30 1852
通常，需要使用CORS_ALLOWED_ORIGINS或CORS_ALLOWED_ORIGIN_REGEXES来限制允许的源列表。首先将CORS_ALLOWED_ORIGINS设置为受信任源的列表，这些源是 允许访问每个 URL，然后将处理程序添加到 check_request_enabled 以允许 CORS，而不考虑 不受限制的网址。2.CORS_ALLOW_HEADERS来自浏览器的请求中允许的非标准 HTTP 请求头的列表。1.CORS_ALLOW_METHODS请求允许的 HTTP 动作的列表。
DRF跨域后端解决之django-cors-headers的使用
09-19
### DRF跨域问题与django-cors-headers的解决方案 #### 跨域问题概述 在Web开发中，出于安全考虑，浏览器实施了同源策略（Same-origin policy）。该策略限制了一个网页上的脚本只能与同一来源的页面进行交互。简单...
【Python】django-cors-headers
day day up
08-18 4720
跨源资源共享 (CORS) 标头添加到响应的 Django 应用程序。这允许从其他来源向您的 Django应用程序发出浏览器内请求。
CORS跨域与前后端联调思路
God_Hearing的博客
09-28 371
CORS跨域 #允许所有源来跨域 CORS_ORIGIN_ALLOW_ALL =True #或者设置跨域请求白名单 # CORS_ORIGIN_WHITELIST = ( # 'http://127.0.0.1:8080', # 'http://localhost:8080', # ) #允许携带cookie CORS_ALLOW_CREDENTALS = True 前后端联调思路 写完视图函数，使用postman进行接口测试，保证后端接口没有问题 在vue中写页面，向后端发送
CORS错误
qq_42108331的博客
08-25 428
CORS错误
django框架技术沉淀
老师好，我是安同学
10-26 1878
关于django框架使用三年的技术沉淀。
django解决跨域请求问题
Hero_s_的博客
04-02 1299
1、安装django-cors-headers模块 pip install django-cors-headers 2、修改setting.py中的配置 INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'dj
django-cors-headers-3.0.2.tar.gz
01-03
**标题解析：** "django-cors-headers-3.0.2.tar.gz" 是一...综上所述，"django-cors-headers-3.0.2.tar.gz" 提供了一个强大的工具，帮助 Django 开发者轻松实现跨域请求的管理和安全性，确保 web 应用程序的正常运行。
django-cors-headers-2.4.0.tar.gz
07-24
`django-cors-headers` 是一个非常重要的Python Django框架扩展，主要用于处理跨域资源共享（CORS）问题。在Web开发中，由于同源策略的限制，浏览器会阻止来自不同源的请求，但有时我们需要允许来自其他源的请求，...
PyPI 官网下载 | django-cors-headers-2.0.2.tar.gz
02-10
总之，django-cors-headers是一个非常实用的Django插件，它使得处理跨域请求变得简单而规范，对于任何使用Django构建的需要支持API或与外部应用交互的后端服务来说，都是一个必不可少的工具。通过深入理解这个库，...
django中的跨域问题以及解决策略
Yietong的博客
11-07 8280
CORS是一个W3C标准，全程跨域资源共享。它允许浏览器向跨源的后端服务器发出ajax请求，从而克服了AJAX只能同源使用的限制。实现CORS主要一开后端服务器响应数据中设置响应头信息返回的CORS需要浏览器和服务器同时支持， 目前除了IE浏览器都支持该功能整个CORS通信过程，都是浏览器自动完成，不需要用户参与。对于开发者来说，CORS通信与同源的AJAX通信没有差别，代码完全一样。浏览器一旦发现AJAX请求跨源，就会自动添加一些附加的头信息，有时还会多出一次附加的请求，但用户不会有感觉。
django-cors-headers实现跨域的方法总结
Deng872347348的博客
04-05 1664
django-cors-headers实现跨域的方法总结
Django解决跨域
YANGGEOL
11-02 128
安装 pip install django-cors-headers 在setting添加代码 # 导入 import corsheaders # 添加配置 INSTALLED_APPS = [ ... 'corsheaders'， ... ] # 添加中间件 MIDDLEWARE = [ ... 'corsheaders.middleware.CorsMiddleware', # 注意顺序 'django.middleware.common.Comm
python使用cors解决跨域问题
Z_Gleng的博客
03-31 867
在MIDDLEWARE添加中间件 放到第三行。在INSTALLED_APPS里面输入。
XSS、CSRF、CORS简介
weixin_68531269的博客
10-26 1075
如果两个 URL 的 协议、端口 (如果有指定的话) 和 主机都相同的话，则这两个 URL 是同源。这个方案也被称为“协议/主机/端口元组”，或者直接是“元组”。（“元组”是指一组项目构成的整体，双重/三重/四重/五重/等的通用形式）。
django2.1.4版本设置跨域问题
m0_47213847的博客
10-05 336
django2.1.4版本设置跨域问题 直接 pip install django-cors-headers django会升级为django3版本，会导致原先的djang2项目出现各种幺蛾子，坑了我一下午时间 所以要安装 pip install django-cors-headers==2.4.0 setting.py 中配置 INSTALLED_APPS = [ ‘corsheaders’, ] MIDDLEWARE = [ … ‘corsheaders.middleware.CorsMiddlewar
Django解决前端跨域问题
qq_66810909的博客
05-13 981
django跨域问题解决
python设置跨域请求_Django设置允许跨域请求
weixin_42501704的博客
02-11 357
1. 安装模块django-cors-headerspip3 install django-cors-headers2. 配置django项目的settings.py文件配置INSTALLED_APPSINSTALLED_APPS = [...,'corsheaders']配置中间件, 注意顺序MIDDLEWARE = [...,'corsheaders.middleware.CorsMiddle...
Django前后端打通
m0_58310590的博客
07-14 1196
用于指定哪些源可以访问资源。用于指定哪些 HTTP 方法允许跨源请求。用于告知浏览器在跨域请求中，所允许的请求头字段。​ 这三个响应头通常一起使用，以确保跨源请求的安全性和可访问性。同时，它们也遵循 CORS 规范，确保浏览器和服务器之间的正确交互。return res。
Django==5.1 django-cors-headers==4.4.0 djangorestframework==3.15.2 djangorestframework-simplejwt==5.3.1 drf-yasg==1.21.7
最新发布
09-07
当你希望你的Django应用能够接收来自不同源（域名、协议或端口）的请求时，使用这个库可以添加适当的HTTP头（CORS headers），允许跨域请求。 3. djangorestframework==3.15.2: Django REST framework 是一个灵活且...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值