Django 路由层 —— 基础用法，以及底层如何实现的

最新推荐文章于 2024-09-22 11:57:21 发布
最新推荐文章于 2024-09-22 11:57:21 发布
阅读量513 收藏 7
点赞数 16
文章标签： django 网络 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_76314178/article/details/142389987
版权

路由层

  • 负责网页 URL 与 函数/类 的对应关系

用法

基本用法

urls.py:

urlpatterns = [
    # 基本用法
    path('login/', views.login),

    # 动态输入参数
    path('info/<int:v1>', views.info),

    # 可以同时传多个参数, path:v3 会记录 v1-v2/ 后面的所有路径
    path('other/<int:v1>-<str:v2>/<path:v3>', views.other),

    # 通过 re_path 应用正则表达式，通过 () 对参数进行分组。
    # r 的作用：告诉编译器需要进行转义
    # re_path 由 django2 引入，在此之前使用的是 url 进行正则
    # 输入 date/2014-02-11  ->  输出 ('2014', '02-11')
    re_path(r'date/(\d{4})-(\d{2}-\d{2})', views.date),
]

views.py:

def login(request):
    return HttpResponse("login")


def info(request, v1):  # 需要设置形参来接受
    return HttpResponse(f"{v1}")


def other(request, v1, v2, v3):
    return HttpResponse(f"{v1, v2, v3}")


def date(request, r1, r2):
    # 输出 ('2014', '02-11')
    return HttpResponse(f"{r1, r2}")

别名

  • 方便后续使用别名反向生产 URL ，以及使用 redirect 重定向
  • 有时还用于分配权限
path('login/', views.login, name="login"),
path('info/<int:v1>', view.info, name="info"),

print(reverse("login"))  # '/login/'
print(reverse("info", kwargs={"v1": 123}))  # '/info/123/'

路由分发

  • 项目较大 -> 一个 urls.py 内容太多 -> 拆分成多个 urls.py

urls.py:

urlpatterns = [
    # 根路由
    path('login/', views.login),  # /login/

    # 使用 include 进行路由分发
    path('another/', include("app.another_urls"))
]

app.another_urls:

urlpatterns = [
    path('login/', views.login)  # /another/login/
]
  • 另一种写法：

urls.py:

urlpatterns = [
    path('login/', views.login),

    # 元组里面放 urlpatterns 列表
    path('another/', ([
        path('login/', views.login)  # /another/login/
    ], None, None))
]

namespace

  • include 函数
def include(arg, namespace=None):
    app_name = None
    if isinstance(arg, tuple):
        try:
            urlconf_module, app_name = arg
        except ValueError:
            # ......
    else:
        # No namespace
        urlconf_module = arg
        
	if isinstance(urlconf_module, str):
        urlconf_module = import_module(urlconf_module)
        
    # ......
    
    # 只提供 namespace 不提供 app_name 会报错
    if namespace and not app_name:
        raise # ......
        
    # ......
    return (urlconf_module, app_name, namespace)

使用 namespace:

# urls.py:
path('another/', include(("app.another_urls", "app"), "ns"))

# another_urls.py:
path('ns/', views.ns, name="n")

# views:
def login(request):
    # print(reverse("n"))  # 在有 namespace 的情况下会报错
    print(reverse("ns:n"))  # namespace 的作用：防止多路由状态下的别名冲突
    return HttpResponse("login")

源码

路由的本质

path('login/', views.login),

#   ↓   path = partial(_path, Pattern=RoutePattern)
#   ↓   partial 是 python 自带的方法，称为偏函数。此处，用于将 Pattern=RoutePattern 参数传递到函数 _path 中
#   ↓   在函数 _path 中会创建一个 URLPattern 对象：URLPattern(pattern, view, kwargs, name)
#   ↓   pattern = Pattern(route, name=name, is_endpoint=True)

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


path('another/', include("app.another_urls"))
#   ↓   
URLResolver(RoutePattern('another/', name=None, is_endpoint=False), "app.another_urls", None, None, None)
  • _path 创建 URLPattern 或 URLResolver 对象部分如下：
def _path(route, view, kwargs=None, name=None, Pattern=None):
    # path('another/', include("app.another_urls"))
    if isinstance(view, (list, tuple)):
        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('login/', views.login)
    elif callable(view):  # callable 用于判定函数是否可执行。简单来说就是 能不能在后面加括号。如：views.login()
        pattern = Pattern(route, name=name, is_endpoint=True)
        return URLPattern(pattern, view, kwargs, name)
  • 关于 URLPattern 和 RoutePattern
# 传入：
URLPattern(RoutePattern('login/', name=None, is_endpoint=True), views.login, None, None)


# URLPattern 
class URLPattern:
    def __init__(self, pattern, callback, default_args=None, name=None):
        self.pattern = pattern  # RoutePattern('login/', name=None, is_endpoint=True)
        self.callback = callback  # views.login
        self.default_args = default_args or {}  # None
        self.name = name  # None
        
# urls.py:
# print("callback: ", urlpatterns[0].callback)  ->  callback:  <function login at 0x0000023A5DBDBA30>


# RoutePattern
class RoutePattern(CheckURLMixin):
    regex = LocaleRegexRouteDescriptor()

    def __init__(self, route, name=None, is_endpoint=False):
        self._route = route  # 'login/', 
        
        # _route_to_regex 的作用：
        # 将路径模式转换为正则表达式。返回正则表达式和一个将捕获名称映射到转换器的字典。
        # 例如，“foo/<int:pk>”将返回“^foo\\/(?P<pk>[0-9]+)” 和 {'pk'： <django.urls.converters.IntConverter>}
        self._regex, self.converters = _route_to_regex(str(route), is_endpoint)
        
        self._regex_dict = {}
        self._is_endpoint = is_endpoint  # is_endpoint=True
        self.name = name  # name=None
        
        
# URLPattern 中嵌入 RoutePattern 的一种用法：
class URLPattern:
    def resolve(self, path):
        # ......
        self.pattern.match  # -> 此处就可以调用 RoutePattern 中的 match 方法
  • 关于 is_endpoint的作用

is_endpoint=True 的作用是标识该路由是一个终点（endpoint）。具体来说：

  1. 路由终点：当 is_endpoint=True 时，Django 知道这个路由条目代表的是一个终点视图函数（比如 views.login），而不是一个子路由的中间层。这表示如果请求路径与该路由匹配，那么这个路径应该由 views.login 这个视图来处理。
  2. 区分子路由和终点：在 Django 路由中，有时会使用 include() 来包含其他的路由配置。对于这些包含的路由，is_endpoint 会被设置为 False，因为它们并不代表一个具体的视图，而是指向另一个路由配置文件。

例如：

urlpatterns = [
    path('login/', views.login),  # 这是一个终点，is_endpoint=True
    path('another/', include("app.another_urls")),  # 这不是一个终点，is_endpoint=False
]

路由匹配的流程

  1. 启动程序，用户访问 URL
  2. 程序执行到 wsgi.py
# Django 项目的 WSGI 配置。
# 它将 WSGI 可调用程序公开为一个名为 ``application`` 的模块级变量。

application = get_wsgi_application()
  1. get_wsgi_application 返回 WSGIHandler对象
def get_wsgi_application():
    """
    Django WSGI 支持的公共接口。返回一个 WSGI 可调用程序。

	避免将 django.core.handlers.WSGIHandler 作为公共 API，以防将来内部 WSGI 实现发生变化或移动。
    """
    django.setup(set_prefix=False)
    return WSGIHandler()
  1. WSGIHandler会调用 __call__
class WSGIHandler(base.BaseHandler):
    request_class = WSGIRequest

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.load_middleware()

    def __call__(self, environ, start_response):
        set_script_prefix(get_script_name(environ))
        signals.request_started.send(sender=self.__class__, environ=environ)
        
        # environ 是用户浏览器发送请求时，携带的所有请求相关的数据
        # request = self.request_class(environ)  =>  request = WSGIRequest(environ)
        # environ 内部的数据杂乱无章，使用 WSGIRequest 进行封装，方便使用
        # request.method
        # request.POST
        # request.path_info
        request = self.request_class(environ)
        
        # 路由的匹配 request.path_info  /login/  ->  读取项目中 urlpatterns 所有的路由
        # 找到相应的函数  views.login
        # 执行函数并返回值  HttpResponse("login")
        response = self.get_response(request)

        # ......
        # 此处完善了 response 的响应报文
        
        return response
  1. response = self.get_response(request)进行路由匹配
def get_response(self, request):
    """根据给出的 HttpRequest 返回一个 HttpResponse 对象."""
    set_urlconf(settings.ROOT_URLCONF)
    
    # self._middleware_chain
    # ->  self._middleware_chain = handler
    # ->  handler = self.adapt_method_mode(is_async, handler, handler_is_async)  # 判断是同步还是异步（目前是同步）
    # ->  handler = convert_exception_to_response(get_response)  # convert_exception_to_response 中间件，负责异常响应
    # ->  get_response = self._get_response_async if is_async else self._get_response  # 判断是同步还是异步（目前是同步）
    # ->  self._get_response：解析并调用视图，然后应用视图、异常和模板响应中间件。该方法就是请求/响应中间件内部发生的一切。
    # 综上：self._middleware_chain(request)  =>  self._get_response(request)
    response = self._middleware_chain(request)
    
    # ......
    return response
  1. self._get_response(request)进行路由匹配
def _get_response(self, request):
    """
    解析并调用视图，然后应用视图、异常和模板响应中间件。该方法就是请求/响应中间件内部发生的一切。
    """
    response = None
    
    # self.resolve_request: 返回已解析的视图及其参数 args 和 kwargs。
    # callback：视图函数
    # callback_args, callback_kwargs：参数，例如 info/<int:v1>/ 里面的 v1
    callback, callback_args, callback_kwargs = self.resolve_request(request)

    # Apply view middleware
    for middleware_method in self._view_middleware:
        # ......

    if response is None:
        # ......

    # Complain if the view returned None (a common error).
    self.check_response(response, callback)

    # If the response supports deferred rendering, apply template
    # 如果响应支持延迟渲染，则应用模板
    # response middleware and then render the response
    # 执行响应中间件并渲染响应
    if hasattr(response, "render") and callable(response.render):
        # ......

    return response
  1. self.resolve_request(request) 返回 ResolverMatch() 对象
def _get_cached_resolver(urlconf=None):
    return URLResolver(RegexPattern(r"^/"), urlconf)  # RegexPattern(r"^/"): 正则匹配，匹配以 '/' 开头的字符串


def get_resolver(urlconf=None):
    if urlconf is None:
        urlconf = settings.ROOT_URLCONF  # ROOT_URLCONF = 'Django.urls'  ->  此处的 Django 是项目名称，'Django.urls' 指向 urls.py
    return _get_cached_resolver(urlconf)


# 注意，此处的 resolve 属于 URLResolver 类，后续会有递归的情况
def resolve(self, path):
    # path = '/login/'
    # path('another/', include("app.another_urls"))
    path = str(path)
    tried = []
    
    # 判断目前访问的 URL 是否与创建的 URLPattern 记录的 URL 相同
    # match = ('login/', (), {})
    # match = ('another/ns/', (), {})
    match = self.pattern.match(path)
    
    if match:
        # new_path = 'login/'
        # new_path = 'another/ns/'
        new_path, args, kwargs = match
        
        
        # self.url_patterns
        # 使用 getattr 反射
        # ->  getattr(self.urlconf_module, "urlpatterns", self.urlconf_module)
        # =>  self.urlconf_module.urlpatterns（如果没有 urlpatterns 就返回 self.urlconf_module）
        
        # self.urlconf_name 在上面 URLResolver(RegexPattern(r"^/"), urlconf) 中获得，值为 urlconf 也就是 'Django.urls'
        # ->  import_module(self.urlconf_name)
        # =>  from Django import urls
        
        # 故上方的 self.urlconf_module.urlpatterns 即为 urls.urlpatterns, 也就是我们所有的定义的路由
        # 开始循环校验
        for pattern in self.url_patterns:
            try:
                
                # pattern.resolve(new_path)
                # 如果是 new_path = 'login/' 的情况：
                    # => URLPattern(RoutePattern('login/', ...), views.login).resolve('login/')
                    # -> match = self.pattern.match(path) => RoutePattern.match('login/')
                    # -> 进行匹配，判断目前访问的 URL 是否与创建的 URLPattern 记录的 URL 相同
                    # 匹配成功，就返回 path[match.end() :], (), kwargs
                    # match = ('login/', (), {})
                    # 再进一步进行封装
                    # 返回 ResolverMatch 对象
                    # ResolverMatch(func=app.views.login, args=(), kwargs={}, url_name=None, app_names=[],namespaces=[], route='login/')
                
                # 如果是 new_path = 'another/ns/' 的情况：
                	# => URLResolver(RoutePattern('another/', ...), "app.another_urls", ...).resolve('another/ns/')
                    # 此时就会递归当前的 resolve 函数
                    # match = self.pattern.match(path) 匹配时，会从 'another/ns/' 匹配出 new_path = 'ns/'，此时为 URLPattern ，同上
                sub_match = pattern.resolve(new_path)
                
            except Resolver404 as e:
                # ......
            else:
                # 匹配成功
                if sub_match:
                    # ......
                    # 对一些参数进行处理
                    # 返回 ResolverMatch 对象
                   # ResolverMatch(func=app.views.login, args=(), kwargs={}, url_name=None, app_names=[], namespaces=[], route='login/')
                    return ResolverMatch(
                        # ......
                    )


def resolve_request(self, request):
    if hasattr(request, "urlconf"):  # 判断是否有 urlconf ，一般默认没有
        # ......
    else:
        resolver = get_resolver()  # resolver = URLResolver(RegexPattern(r"^/"), 'Django.urls')
        
    # 解析视图，并将匹配对象重新分配给请求。
    # resolver.resolve(request.path_info)  ->  resolver.resolve('/login/')
    # resolver_match = ResolverMatch(func=app.views.login, ......, route='login/')
    resolver_match = resolver.resolve(request.path_info)
    
    # 赋值给 request ，request.resolver_match = ResolverMatch(func=app.views.login, ......, route='login/')
    request.resolver_match = resolver_match
    return resolver_match
  • WSGI：

WSGI(Python Web Server Gateway Interface，即Web服务器网关接口) 是 Python 定义的 Web 服服务器和 Web 应用程序或框架之间的一种简单而通用的接口。

它是 Python 为了解决 Web 服务器端与客户端之间的通信问题而产生的，它基于现存的 CGI 标准而设计。其定义了 Web 服务器如何与 Python 应用程序进行交互，让 Python 写的 Web 应用程序可以和 Web 服务器对接起来。

  • __call__:

使一个类可以像函数一样调用。

使用时，x() 等价于 x.__call__() 

class A(object):
    def __init__(self, name, age, male):
        self.name = name
        self.age = age
        self.male = male
 
    def __call__(self, name, age):
        self.name, self.age = name, age
 
 
if __name__ == '__main__':
    a = A('dgw', 25, 'man')
    print(a.age, a.name)  # 25 dgw
    a('zhangsan', 52)
    print(a.name, a.age)  # zhangsan 52
  • 7 到 1:

self.resolve_request(request) 返回 resolver_match -> ResolverMatch() 对象 （ResolverMatch(func=app.views.login, args=(), kwargs={}, url_name=None, app_names=[], namespaces=[], route='login/')）

self._get_response(request) 返回 response -> <HttpResponse status_code=200, "text/html; charset=utf-8">

然后一直往上，返回响应报文

源码的应用（用的不多）

自定义拓展：

Class MYURLPattern(URLPattern):
    def ... :
        pass

MYURLPattern(RoutePattern('login/', name=None, is_endpoint=True), views.login, None, None)

补充：关于网址后面的"/"

  • Django 的默认设置 地址
...\envs\Lib\site-packages\django\conf\global_settings.py
  • Django 的默认设置中，有一个 APPEND_SLASH = True，他的功能是：
# 在访问 "/login" 时，自动重定向到 "/login/"
path('login/', views.login)

注意： 重定向后，访问的方法是 GET 方法。如果使用 POST 访问 “/login”，重定向后会出问题。

  • 可以在 setting.py 中，添加 APPEND_SLASH = False
司马乐家
关注
Django源码之路由的本质（上）——逐步剖析底层执行流程
xiao_a_lian的博客
03-31 1161
在学习Django框架的时候，我们大多时候都只会使用如何去开发项目，对其实现流程并不是很清楚明了。这篇文章的目的就是带你先从Django最基础的路由层开始剖析底层源码，一步一步带你学会，Django路由是如何来进行实现的，它的底层又是基于什么来完成的。
Django源码之路由匹配（下）——图解逐步分析底层源码
xiao_a_lian的博客
04-01 1505
学习Django如何进行路由匹配，可以更好的掌握Django框架，学习源码编写的思想，可以帮助我们自己写出更健硕、更容易维护和扩展的代码。
Django路由分发的三种方式以及命名空间namespce——附带源码解析
xiao_a_lian的博客
04-03 1306
本篇文章主要是讲解路由分发的三种方式。当然，你可能在想，一般做路由分发只需要一个include就能搞定，为什么还有另外三种方式呢。 这个就要追溯到Django的底层源码了， 通过研究Django中include的底层源码了，从而发现另外两种作路由分发的方式。
Django学习——路由
记录学习路上的一些拙见
07-11 226
Django学习——路由模块
Python-Django 建站 —— 第四篇
Lisa_oliv的专栏
02-21 453
一、FBV视图 视图View是Django的MTV架构模式的V部分，负责处理用户请求和生成响应的响应内容。在视图里定义def函数，这种方式称为FBV（Function Base Views） 1，设置响应方式 1.1 返回响应内容
自动化测试平台搭建系列（7）——Django中的路由配置及规则
十七光年的博客
09-01 326
文章目录
4. Django 路由
mannixiang的博客
04-02 183
Django 路由 版权声明：本博客来自路飞学城Python全栈开发培训课件，仅用于学习之用，严禁用于商业用途。 欢迎访问路飞学城官网：https://www.luffycity.com/ 本节重点 路由（URLconf）简介 正则路径中的分组 路由分发 反向解析 命名空间 1. 路由（URLconf）简介 路由简单的来说就是根据用户请求的 URL 链接来判断对应的处理程序，并返回处理结果，也就是 URL 与 Django 的视图建立映射关系。 Django 路由在 urls.py 配置，urls.py
Django教程——入门阶段（二）模拟登陆
weixin_39560274的博客
02-02 366
写在前面 这一系列的博客适用于零基础的想要使用Django开发网页的人，由浅至深，分为入门，进阶，技巧三个篇章。 （三）模型类 1.用途 完成和数据库的交互 2.逻辑 我们假设有一个登录逻辑，用户需要输入用户名和密码才能够访问网站主页。那么数据库中就必须存储用户名和密码的信息。 3.操作 第一步： 在应用SimpleWebsite的models.py中写入如下代码 class User(mo...
Web框架与Django路由层
m0_71115526的博客
11-28 1720
对于一些复杂或者复用的需要，可以定义自己的转化器。regex类属性，字符串类型方法，value是由类属性regex所匹配到的字符串，返回具体的Python变量值，以供Django传递到对应的视图函数中。方法，和to_python相反，value是一个具体的Python变量值，返回其字符串，通常用于url反向引用。使用...
【Django-vue-admin学习笔记】dvadmin用户功能基础models解析
Mr数据杨
04-20 295
通过本文的详细介绍可以看到在一个复杂的软件项目中，如何通过精心设计的数据模型来管理各种类型的信息和业务流程。每个类都是项目中不可或缺的一部分，它们相互协作，提供了一个全面、高效和灵活的数据管理解决方案。从Users类的详细用户管理到类的消息处理，每个模型都通过其方法和属性为软件项目的顺利运行提供支持。这些数据模型展示了在现代软件开发中，结构化和有组织的数据处理方法的重要性，为构建可靠、高效和可扩展的软件应用提供了坚实的基础。
Django全栈开发学习笔记（五）——重定向视图、基础视图、列表视图、详细视图
烧麦Star
02-25 277
视图基础知识2 1.数据显示视图 数据显示视图是将后台的数据展示在网页上，数据主要来自模型，一共有4个视图类，分别是RedirectView、TemplateView、ListView、DetailView。 RedirectView 用于实现HTTP重定向，默认情况下之定义GET请求的处理方法。 TemplateView 是视图类的基础视图，可将数据传递给HTML模板，默认情况下之定义GET请求的处理方法。 ListView 是在TemplateView 基础上将数据以列表显示，通常用来显示数据表 1
Django 基础
hkxpz的博客
01-28 804
1 HTTP协议 1.1 简介 超文本传输协议，是一种用于分布式、协作式和超媒体信息系统的应用层协议。 现今广泛使用的一个版本为–HTTP 1.1 HTTP是一个客户端（用户）和服务端（网站）请求和应答的标准（TCP）。 通常由HTTP客户端发起一个请求，创建到一个服务器指定端口（默认是80端口）的TCP连接。HTTP服务器则在那个端口接收客户端请求。一旦收到请求，服务器就会向客户端返回一个状态，如“HTTP/1.1 200 OK”，以及返回的内容，如请求的人间、错误的信息或者其他信息 1.2 HTTP
python全栈开发基础知识学习——Django框架（三、Template模块）
Dim_Jerry的博客
08-24 365
Django框架(三）一、模板(Template)简介1.简介2.模板系统简介Django模板语言模板变量 一、模板(Template)简介 1.简介 作为一个Web框架，Django需要一种动态生成HTML的便捷方式。最常见的方法依赖于模板。模板包含所需HTML输出的静态部分以及描述如何插入动态内容的一些特殊语法。 Django项目可以配置一个或多个模板引擎（如果不使用模板，甚至可以为零）。Dj...
Django全栈开发学习笔记（六）——数据操作视图：增、改、删
烧麦Star
03-02 396
视图基础知识3 1数据操作视图 数据操作视图是对数据模型进行操作，如增、删、改，从而实现Django与数据库的数据交互。一共有4种视图类分别是FormView、CreateView、UpdateView和DeleteView。 FormView：视图类使用内置的表单功能，通过表单实现数据验证、响应输出等功能，用于显示表单数据 CreateView：实现模型的数据新增功能，通过内置的表单功能实现数据新增 UpdateView：实现模型的数据修改功能，通过内置表单功能实现数据修改 DeleteView：实现模
计算机毕业设计 基于Python的校园个人闲置物品换购平台 闲置物品交易平台 Python+Django+Vue 前后端分离 附源码 讲解 文档
weixin_19164791635
09-21 1612
本文介绍了一款基于Java、SpringBoot和Vue.js技术的校园个人闲置物品换购平台。该平台服务于管理员、置换账户和用户，提供闲置商品浏览、交流论坛、校园资讯获取等功能。旨在促进资源循环利用，减少浪费，同时为学生提供经济实惠的购物选择，推动校园环保文化的建设。
基于python+django+vue的图书管理系统
计算机学姐的博客
09-19 1395
【2025最新】基于python+django+vue+MySQL的图书管理系统，前后端分离。
Vue.js与Flask/Django后端配合详细讲解
yang_xs的博客（只讲干货）
09-19 1348
Vue.js 与 Flask 或 Django 的结合可以形成一个强大的前后端分离架构，适合构建现代 web 应用。以下是详细讲解如何将 Vue.js 与 Flask/Django 后端配合使用。
Django 请求配置
最新发布
A乐神的博客
09-22 808
Django 请求配置
Django URLconf路由实现详解
"了解Django路由层URLconf的实现对于开发高效且灵活的Web应用程序至关重要。本文将深入探讨这一主题，并通过实例代码展示如何利用分组和分发功能增强URL配置。" Django的URLconf（URL配置）是其强大功能的一部分，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值