Django 路由系统

已于 2023-08-03 15:43:13 修改
阅读量64 收藏
点赞数
分类专栏： Django学习 文章标签： django python
于 2023-07-25 20:12:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42222846/article/details/131774409
版权

1.常见路由操作

在这里插入图片描述

2. name 别名

别名主要是用于方便后续使用特别长的路由，不写全全部路由，而起了一个简短的名字
例如：一个api路径为api/auth/user/login/

  #定义了一个路由api/auth/user/login/，取了一个n1的别名
  path('api/auth/user/login/', views.login, name='n1') 
  #也等价于下面这种
  URLPattern(RoutePattern("login/", name="n1", is_endpoint=True), views.login, None, "n1"),

 def login(request):
        return HttpResponse("欢迎登陆")

    from django.urls import reverse
    
    result = reverse("n1")
    print(result) # "api/auth/user/login/"

如果路径中带有参数的，可以使用kwargs加入

path('api/auth/login/<int:v1>/', views.login, name='n1'),

from django.urls import reverse

result = reverse("n1",kwargs={"v1":123})
print(result) # "/api/auth/login/123/"

在实际运用中，假设有2个函数

path('api/auth/login/',  views.login,  name='n1'), #登录
path('api/user/account/', views.account, name='n2'),#账号信息

def login(request):
    # 当用户登录成功之后，需要让用户跳转到 /api/user/account/ 页面
    # return redirect("/api/user/account/")
    
	# url = reverse("n2")   # "/api/user/account/"
    # return redirect(url)

	return redirect("n2")
    
def account(request):
    return HttpResponse("用户信息")

ps: redirect后可以直接带别名，内部会默认先reverse生成url再重定向

3. 路由分发

假设存在多个app，不同的处理逻辑分布在不同的app里面，就可以使用include路由分发
在这里插入图片描述

4. 路由本质*

4.1 include 源码

# django.urls.include
def include(arg, namespace=None):
    app_name = None
    if isinstance(arg, tuple):
        # Callable returning a namespace hint.
        try:
            urlconf_module, app_name = arg
			...
    else:
        urlconf_module = arg

if isinstance(urlconf_module, str):
	urlconf_module = import_module(urlconf_module)
	
patterns = getattr(urlconf_module, 'urlpatterns', urlconf_module)
app_name = getattr(urlconf_module, 'app_name', app_name)

path('api/',include('apps.base.urls'))
----------->等价于
path('api/',(import_module('apps.base.urls'),None,None))

在这里插入图片描述
通过这种方法同样可以成功访问。

4.2 path源码

通过源码可以查看

path = partial(_path, Pattern=RoutePattern)


def _path(route, view, kwargs=None, name=None, Pattern=None):
    ...
    elif callable(view):
        pattern = Pattern(route, name=name, is_endpoint=True)
        return URLPattern(pattern, view, kwargs, name)
   ...

最后返回的是一个URLPattern类，

URLPattern(Pattern(route, name=name, is_endpoint=True), view, kwargs, name)

path('login/', views.login),
所以通过path()这个函数，本质上是创建了一个URLPattern对象
----->
URLPattern(
    RoutePattern("login/", name=None, is_endpoint=True),
    views.login,
    None,
    None
),

在执行path的时候，传入参数种类可以有

  • 网址+函数 ，返回的是URLPattern对象
path('login/', views.login),
-------------------->
URLPattern(
    RoutePattern("login/", name=None, is_endpoint=True),
    views.login,
    None,
    None
),
  • 网址+（模块对象，None，None），返回的是URLResolver对象
def _path(route, view, kwargs=None, name=None, Pattern=None):
    if isinstance(view, (list, tuple)):
        # For include(...) processing.
        pattern = Pattern(route, is_endpoint=False)
        urlconf_module, app_name, namespace = view
        return URLResolver(
            pattern,
            urlconf_module,
            kwargs,
            app_name=app_name,
            namespace=namespace,
        )
        ....

 path('api/', include("apps.base.urls")),
 path('api/', (
     import_module("apps.base.urls"),              # 模块对象 from app.base import urls
     None, 
     None)
 ),
 --------------------------------->等价于
 URLResolver(
    RoutePattern('api/',name=None,is_endpoint=False),
    import_module("apps.base.urls"),              # 模块对象 from app.base import urls
    None,
    app_name=None,
    namespace=None
)
  • 网址+（列表，None，None）
 path('web/', (
        [
        	path('v1/', www_views.login, name='v1'),
        	path('v2/', www_views.login, name='v2'),
		], 
        None, 
        None)
	),
------------------------------------>等价于
URLResolver(
    RoutePattern('api/',name=None,is_endpoint=False),
	[
        path('v1/', www_views.login, name='v1'),
        path('v2/', www_views.login, name='v2'),
    ], 
    None,
    app_name=None,
    namespace=None
)

总结，所有URL用类和对象嵌套的形式实现：

from django.urls import path, re_path, include
from apps.www import views

from django.urls import URLPattern, ResolverMatch
from django.urls.resolvers import RoutePattern
from importlib import import_module
from apps.www import views as www_views
from django.urls.resolvers import URLResolver

urlpatterns = [
    URLPattern(
        RoutePattern("login/", name=None, is_endpoint=True),
        views.login,
        None,
        None
    ),
    URLResolver(
        RoutePattern('api/', name=None, is_endpoint=False),
        import_module("apps.base.urls"),  # 模块对象 from app.base import urls
        None,
        app_name=None,
        namespace=None
    ),
    URLResolver(
        RoutePattern('web/', name=None, is_endpoint=False),
        [
            path('v1/', www_views.login, name='v1'),
            path('v2/', www_views.login, name='v2'),
        ],
        None,
        app_name=None,
        namespace=None
    )
]

5. 匹配的流程*

核心就是执行URLPattern的resolve方法，而resolve调用的是RoutePattern的match方法.遍历定义的urlpatterns ，执行每一个独享的resolve方法，

urlpatterns = [
    URLPattern(RoutePattern("login/", name=None, is_endpoint=True) , views.login, None, None),  # resolve -> RoutePattern.match
    URLPattern(RoutePattern("login2/", name=None, is_endpoint=True) , views.login, None, None),  # resolve -> RoutePattern.match
    URLPattern(RoutePattern("login3/", name=None, is_endpoint=True) , views.login, None, None),  # resolve -> RoutePattern.match
    URLPattern(RoutePattern("login4/", name=None, is_endpoint=True) , views.login, None, None),  # resolve -> RoutePattern.match
    path('login/', views.login),  # resolve
]

后续再进行路由匹配时：
1.源码流程
    ....
    django.urls.resolves.URLResolver.resolve

2.开始路由匹配
    for pattern in urlpatterns:
        sub_match = pattern.resolve("用户请求的URL")  # RoutePattern.match("用户请求的URL")
        if sub_match:
        #匹配成功，就返回了一个ResolverMatch对象
            reutrn ResolverMatch(
                    sub_match.func,
                    sub_match_args,
                    sub_match_dict,
                    sub_match.url_name,
                    [self.app_name] + sub_match.app_names,
                    [self.namespace] + sub_match.namespaces,
                    self._join_route(current_route, sub_match.route),
                    tried,
                    captured_kwargs=sub_match.captured_kwargs,
                    extra_kwargs={
                        **self.default_kwargs,
                        **sub_match.extra_kwargs,
                    },
                )
	# 如果匹配成功，会把这个 ResolverMatch对象赋值给request
    request.resolver_match = ResolverMatch对象

3.执行视图函数
  1. 请求开始
    请添加图片描述
  2. 路由匹配请添加图片描述
    请添加图片描述
    请添加图片描述
  3. 匹配过程
def resolve_request(self, request):
		...
        resolver = get_resolver()

匹配从这里开始，会创建URLResover对象

def get_resolver(urlconf=None):
    if urlconf is None:
        urlconf = settings.ROOT_URLCONF
    return _get_cached_resolver(urlconf)

将路由的地址传递进来，给 _get_cached_resolver()，这里urlconf实际就是settings里的创建的'day006.urls'
在这里插入图片描述

@functools.lru_cache(maxsize=None)
def _get_cached_resolver(urlconf=None):
    return URLResolver(RegexPattern(r'^/'), urlconf)

假设用户请求一个网址 /info/v1
最开始就返回一个URLResolver对象，RegexPattern(r’^/')是一个正则表达式

class URLResolver:
    def __init__(self, pattern, urlconf_name, default_kwargs=None, app_name=None, namespace=None):
        self.pattern = pattern
        # self.pattern = RegexPattern(r'^/')
        self.urlconf_name = urlconf_name
        # self.urlconf_name = 'day006.urls'
  		...

得到URLResover对象后，执行对象里面的resolve方法

    def resolve_request(self, request):
    	...
  		resolver = get_resolver()
  		...
        resolver_match = resolver.resolve(request.path_info)
        ...

def resolve(self, path):
   path = str(path)  # path may be a reverse_lazy object
   tried = []
   # 1. 首先执行pattern.match
   match = self.pattern.match(path)
   if match:
       new_path, args, kwargs = match
       for pattern in self.url_patterns:
...



@cached_property
def urlconf_module(self):
    if isinstance(self.urlconf_name, str):
        return import_module(self.urlconf_name)
    else:
        return self.urlconf_name
        
  @cached_property
def url_patterns(self):
    patterns = getattr(self.urlconf_module, "urlpatterns", self.urlconf_module)
 ...

根据urlconf_name 导入根路由‘day006.urls’，然后再getattr，获取根路由里面的urlpatterns

def resolve(self, path):
		...
       new_path, args, kwargs = match
       for pattern in self.url_patterns:

这里就循环获取到的根路由里所有的路由

路由本质底层又是 URLPattern对象，URLResover对象

```python
    def resolve(self, path):
		...
        if match:
            new_path, args, kwargs = match
            for pattern in self.url_patterns:
                try:
                    sub_match = pattern.resolve(new_path)

这里循环这些URLPattern/URLResover对象，然后执行对象的resolve方法，new_path 等于匹配到的新路由 info/v1/

URLPattern(
    RoutePattern("login/", name=None, is_endpoint=True),
    views.login,
    None,
    None
)


class URLPattern:
    def __init__(self, pattern, callback, default_args=None, name=None):
        self.pattern = pattern
        # self.pattern = RoutePattern("login/", name=None, is_endpoint=True)
        self.callback = callback  # the view
        # self.callback = views.login  视图函数
        ....
    def resolve(self, path):
        match = self.pattern.match(path)
        ...

这里就调用pattern的match进行匹配，也就是RoutePattern("login/", name=None, is_endpoint=True)对象的match方法

class RoutePattern(CheckURLMixin):
    regex = LocaleRegexDescriptor('_route')

    def __init__(self, route, name=None, is_endpoint=False):
        self._route = route
        # self._route = ‘login/’
        self._is_endpoint = is_endpoint
        # self._is_endpoint = True
        ...

    def match(self, path):
      	...
        return path[match.end():], (), kwargs
        ...

match本质上就是拿着这个'login/'和用户请求的URL进行匹配，最后返回
	return path[match.end():], (), kwargs
	匹配成功的切片

如果是路由分发，会先匹配自己的前缀，再去分发的路由逐一进行匹配

请添加图片描述

6. 关于网址后面 ‘/’

# 如果有一个路由是这样的
path('login/', views.login, name='login')
#那么直接请求’.../login/‘   是肯定能请求成功的
	http://127.0.0.1:8000/login/  成功
# 如果连接是'.../login',那么会执行一次重定向，重新自动请求'.../login/'	
	http://127.0.0.1:8000/login   重定向，GET
	http://127.0.0.1:8000/login/

当直接访问或者get请求访问，会成功，但是如果POST请求就会出错。
在这里插入图片描述
如果在settings里设置了APPEND_SLASH = False，那么就会是严格模式，第一什么就以什么方式访问。此时如果再访问'.../login'就会报错。

7. Django和Flask对于request处理的区别

  • Django将request对象逐一传递，最后到视图函数的是经过层层封装的request对象，可以调用里面各种属性和方法
  • Flasks将request对象独立出去，哪里需要用到，再去进行用和修改。

在这里插入图片描述

ILUUSION_S
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Django路由系统精讲
ccc369639963的博客
05-17 184
Django路由系统精讲 在前一节中，我们对 URL 有了基本的认识，在本节将对 Django 的路由系统展开详细的讲解， 让我们更加清楚的了解 URL 在 Django 中到底是如何应用的。 1. Django 路由系统应用 一个用户向 Web 站点发送请求，是通过 URL 实现的，当 Web 服务器端接收到用户请求后，它又是怎么处理的呢？通过 MTV 的设计模式，我们可以得知，首先用户请求会到达相应的视图函数，那么视图函数又是怎样找到相应的访问资源的呢，在这里就用到了“路由系统”。 Django 中利用
Django路由系统
Allen_by的博客
04-06 1009
路由系统Django处理HTTP请求流程URL参数类型转化器自定义URL参数类型转化器使用正则表达式导入其他URLconf向视图传递额外参数使用include() 方法传递额外参数动态生成URLURL名字和命名空间 Django处理HTTP请求流程 用户发起一个HTTP请求 确定URL根路由配置位置 加载配置信息，在配置信息中查找urlpatterns 按顺序检索urlpatterns中的所有U...
Django 路由系统（详解）
梁辰兴的博客
11-11 555
在 django.conf.urls 中封装了路由模块，新建的 Django 项目中提供了 urls.py（创建项目后自动生成的配置文件） 路由配置文件，urls.py 文件中定义了一个 urlpatterns 的列表，它是由 url( ) 实例对象组成的列表，Django 中 url 的定义就是在这个列表完成的。在《URL是什么》一节中，我们对 URL 有了基本的认识，在本节将对 Django 的路由系统展开详细的讲解， 让我们更加清楚的了解 URL 在 Django 中到底是如何应用的。
一张图看懂Django路由系统
qq_43665434的博客
04-11 864
一张图看懂Django路由系统 1、传参 a、转换器传参 在传参的部分有一个路由转换器，其作用就是将URL中的路由参数转换为指定的类型，在形式上分为两种，内置路由转换器和自定义路由转换器。 内置路由转换器 可以显示地指定路由中参数地数据类型，例如<str:phone>，就是指定路由参数phone的数据类型为str。 内置的路由转换器共有5中： str：匹配出路由分隔符“/”之外的所有非空字符串。（默认） int：匹配0或任何正整数 slug：匹配有字母、数字、连字符和下画线（英文形式）
7、Django进阶：Django路由系统精讲：揭秘Django的路由系统从URL映射到视图处理的全过程（必掌握）
SteveRocket's-Blog
12-11 677
对路由系统的定义和URL的模式做了介绍。 详细介绍了Django路由系统的定义与使用，包括URL映射与路由匹配、参数传递与命名URL等内容。 介绍了URLconf的配置和使用方法、URL的名称和反向解析，以及URL的参数。 通过合理配置路由系统，我们能够实现灵活的URL映射和请求分发。 通过include实现URLconf的嵌套 Django路由系统的应用示例。 URL的映射和路由匹配，以及路由系统的一个最佳实践。 本文的最后一节总结了Django的三种路由配置方式：path()、re_path()
Django 路由系统详解
06-24 485
Django 是一个高级 Python Web 框架，它鼓励快速开发和干净、实用的设计。在 Django 中，路由系统是其核心组件之一，负责将用户的请求映射到相应的视图函数或类。本文将深入探讨 Django 的路由系统，包括其工作原理、配置方式以及高级功能。
django学习笔记（4）—— Django路由系统
zyw2002的博客
11-25 915
4. Django路由系统 4.1 路由系统基本配置 Django路由系统配置代码在urls.py中，该文件在创建项目时自动生成，一般在项目目录下。如前面建立的test_orm项目，urls.py文件就在/test_orm/test_orm/目录下。 4.1.1 路由系统URL基本格式 在urls.py文件中配置的路由，都存放在一个名为urlpatterns的变量中，这个变量是列表类型，如下所示 from django.contrib import admin from django.urls import
Django 路由系统之动态路由
windyJ809的博客
08-03 479
写在前面 首先我们要知道，在Django框架中有一个配置文件叫url.py，这个文件里面操纵的就是我们的路由系统。他是用于记录 Django 项目的 URL 映射关系，也就是说，这个文件里面实现了url和我们view.py文件中函数的对应关系。下面我们就来具体说下他们是怎么实现对应的 一、一一对应 在url.py文件中，使用这样的格式，就能实现url和view中函数的一一对应关系：如/login/->def login urlpatterns = [ # path('admin/', admi
Day 57 django 路由系统 反向解析
Tao.的博客
09-01 386
django 路由匹配 反向解析
Django 路由系统URLconf的使用
01-21
URL配置(URLconf)就像Django 所支撑网站的目录。它的本质是URL与要为该URL调用的view函数之间的映射表；你就是以这种方式告诉Django，对于这个URL调用这段代码，对于那个URL调用那段代码。 urlpatterns = [ url...
Django基础知识 URL路由系统详解
09-19
### Django基础知识 URL路由系统详解 #### 一、MVC与MTV框架的理解 - **MVC框架**（Model-View-Controller）： - **模型（Model）**：负责业务对象与数据库之间的映射（ORM），即数据层的管理。 - **视图（View...
Django之路由层
09-18
Django之路由层 Django之路由层是Django框架中的一部分，主要负责将URL请求映射到对应的视图函数上。这个层次结构类似于文件系统的目录结构，用于组织和管理项目中的URL请求。 一、简单的路由配置 Django之路由层...
Django 路由
12-20
总结起来，Django路由系统是通过URL配置文件（通常为`urls.py`）将用户请求的URL映射到对应的视图函数，实现业务逻辑的执行。随着版本更新，Django提供了更加友好和灵活的路由配置方式，如`path()`和`re_path()`，...
26.3 Django路由层
06-24
【Django路由层详解】 Django作为Python中最受欢迎的Web框架之一，其强大的功能和高效的设计模式深受开发者喜爱。在Django中，路由系统是连接URL到特定视图（views）的关键部分，使得用户请求能够被正确处理并返回...
Django中事务的基本使用
最新发布
清风
08-06 214
在Django框架中, transaction模块是用于管理数据库事务的关键组件.事务是确保数据库操作原子性, 一致性, 隔离性和持久性(ACID特性)的重要机制.Django通过transaction模块提供了灵活的事务管理功能, 允许开发者在应用程序中根据需要手动控制事务的边界.注意: 虽然Django ORM提供了对事务的支持，但具体的事务行为(如隔离级别, 持久性等)会根据使用的数据库后端而有所不同.
26.9 Django书籍管理练习
清风
08-03 510
1.4.1 作者表 1.4.5 完整代码 1.4.6 数据库迁移 1.5.1 作者表记录 1.5.3 出版社表记录 1.5.5 书籍作者关联表 2.1 路由层 2.3.4 主页面板
智慧水务项目（四）django(drf)+angular 18 添加drf_yasg api接口文档
浪淘沙jkp的专栏
08-02 320
文档api接口是必须的本来准备用coreapi，据说drf_yasg更流弊。
Django内置后端和自定义后端
brucexia的专栏
08-06 902
在Django框架中，还设置了一种自定义后端。一个自定义后端是一个继承自django.template. backends.base.BaseEngine的类，必须实现get_template()函数方法和可选的from_string()函数方法。下面，请看一个自定义的foobar模板库的示例。【代码5-9】04060809 # 包含该模板引擎的模板的子目录名称10 # 在已安装的应用程序内12171921 try:2527 try:333538。
智慧水务项目（二）django(drf)+angular 18 创建通用model，并对orm常用字段进行说明
浪淘沙jkp的专栏
08-02 436
上一篇文章建立一个最简单的项目，现在我们建立一个公共模型，抽取公共字段，以便于后续模块继承，过程之中会对orm常用字段进行说明，用到的介绍一下。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值