Django之路由层

时间  2019-11-07
标签 django 路由 栏目 Python 繁體版
原文   原文链接

Django之路由层

路由是个啥

undefined

路由即请求地址与视图函数的映射关系，若是把网站比喻为一本书，那路由就比如是这本书的目录，在Django中路由默认配置在urls.py中，以下图：html

undefined

简单的路由配置

# urls.py 
from django.conf.urls import url

# 由一条条映射关系组成的urlpatterns这个列表称之为路由表
urlpatterns = [
     url(regex, view, kwargs=None, name=None), # url本质就是一个函数
]
#函数url关键参数介绍
# regex：正则表达式,用来匹配url地址的路径部分，
        # 例如url地址为：http://127.0.0.1:8001/index/，正则表达式要匹配的部分是index/
# view：一般为一个视图函数，用来处理业务逻辑
# kwargs：略（用法详见有名分组）
# name：略（用法详见反向解析）

案例：python

urls.py文件git

from django.conf.urls import url
from django.contrib import admin
from app01 import views # 导入模块views.py

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    
    url(r'^index/$',views.index), # 新增一条
]

views.py文件正则表达式

from django.shortcuts import render
from django.shortcuts import HttpResponse # 导入HttpResponse，用来生成响应信息

# 新增视图函数index
def index(request):
    return HttpResponse('index page...')

测试：django

python manage.py runserver 8001 # 在浏览器输入：http://127.0.0.1:8001/index/ 会看到 index page...

注意一：浏览器

刚刚咱们在浏览器输入：http://127.0.0.1:8001/index/，Django会拿着路径部分index/去路由表中自上而下匹配正则表达式，一旦匹配成功，则当即执行其后的视图函数，不会继续往下匹配，此处匹配成功的正则表达式是`r'^index/$’。**app

注意二：函数

可是咱们在浏览器输入：http://127.0.0.1:8001/index，Django一样会拿着路径部分index去路由表中自上而下匹配正则表达式，貌似并不会匹配成功任何正则表达式（r'^index/$'匹配的是必须以/ 结尾，因此不会匹配成功index），但实际上仍然会看到结果 index page..…，缘由以下：post

在配置文件settings.py中有一个参数APPEND_SLASH，该参数有两个值True或False测试

当APPEND_SLASH=True（若是配置文件中没有该配置，APPEND_SLASH的默认值为True），而且用户请求的url地址的路径部分不是以 / 结尾，例如请求的url地址是 http://127.0.0.1:8001/index，Django会拿着路径部分（即index）去路由表中匹配正则表达式，发现匹配不成功，那么Django会在路径后加/（即index/）再去路由表中匹配，若是匹配失败则会返回路径未找到，若是匹配成功，则会返回重定向信息给浏览器，要求浏览器从新向 http://127.0.0.1:8001/index/地址发送请求。

当APPEND_SLASH=False时，则不会执行上述过程，即一旦url地址的路径部分匹配失败就当即返回路径未找到，不会作任何的附加操做

分组

undefined

什么是分组、为什么要分组呢？好比咱们开发了一个博客系统，当咱们须要根据文章的id查看指定文章时，浏览器在发送请求时须要向后台传递参数（文章的id号），可使用 http://127.0.0.1:8001/article/?id=3，也能够直接将参数放到路径中http://127.0.0.1:8001/article/3/

针对后一种方式Django就须要直接从路径中取出参数，这就用到了正则表达式的分组功能了，分组分为两种：无名分组与有名分组

undefined

无名分组

urls.py文件

from django.conf.urls import url
from django.contrib import admin
from app01 import views

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    
    # 下述正则表达式会匹配url地址的路径部分为:article/数字/，匹配成功的分组部分会以位置参数的形式传给视图函数，有几个分组就传几个位置参数
    url(r'^aritcle/(\d+)/$',views.article), 
]

views.py文件

from django.shortcuts import render
from django.shortcuts import HttpResponse

# 须要额外增长一个形参用于接收传递过来的分组数据
def article(request,article_id):
    return HttpResponse('id为 %s 的文章内容...' %article_id)

测试：

python manage.py runserver 8001 # 在浏览器输入：http://127.0.0.1:8001/article/3/ 会看到: id为 3 的文章内容...

有名分组

urls.py文件

from django.conf.urls import url
from django.contrib import admin
from app01 import views

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    
    # 该正则会匹配url地址的路径部分为:article/数字/，匹配成功的分组部分会以关键字参数（article_id=匹配成功的数字）的形式传给视图函数，有几个有名分组就会传几个关键字参数
    url(r'^aritcle/(?P<article_id>\d+)/$',views.article), 
]

views.py文件

from django.shortcuts import render
from django.shortcuts import HttpResponse

# 须要额外增长一个形参，形参名必须为article_id
def article(request,article_id):
    return HttpResponse('id为 %s 的文章内容...' %article_id)

测试：

python manage.py runserver 8001 # 在浏览器输入：http://127.0.0.1:8001/article/3/ 会看到: id为 3 的文章内容...

总结：有名分组和无名分组都是为了获取路径中的参数，并传递给视图函数，区别在于无名分组是以位置参数的形式传递，有名分组是以关键字参数的形式传递。

强调：无名分组和有名分组不要混合使用

路由分发

undefined

随着项目功能的增长，app会愈来愈多，路由也愈来愈多，每一个app都会有属于本身的路由，若是再将全部的路由都放到一张路由表中，会致使结构不清晰，不便于管理，因此咱们应该将app本身的路由交由本身管理，而后在总路由表中作分发，具体作法以下

  1. 建立两个app
# 新建项目mystie2
E:\git>django-admin startproject mysite2
# 切换到项目目录下
E:\git>cd mysite2
# 建立app01和app02
E:\git\mysite2>python3 manage.py startapp app01
E:\git\mysite2>python3 manage.py startapp app02

2.在每一个app下手动建立urls.py来存放本身的路由，以下：

app01下的urls.py文件

from django.conf.urls import url
# 导入app01的views
from app01 import views

urlpatterns = [
    url(r'^index/$',views.index), 
]

app01下的views.py

from django.shortcuts import render
from django.shortcuts import HttpResponse

def index(request):
    return HttpResponse('我是app01的index页面...')

app02下的urls.py文件

from django.conf.urls import url
# 导入app02的views
from app02 import views

urlpatterns = [
    url(r'^index/$',views.index), 
]

app02下的views.py

from django.shortcuts import render
from django.shortcuts import HttpResponse

def index(request):
    return HttpResponse('我是app02的index页面...')
  1. 在总的urls.py文件中（mysite2文件夹下的urls.py）
from django.conf.urls import url,include
from django.contrib import admin

# 总路由表
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    
    # 新增两条路由，注意不能以$结尾
    # include函数就是作分发操做的，当在浏览器输入http://127.0.0.1:8001/app01/index/时，会先进入到总路由表中进行匹配，正则表达式r'^app01/'会先匹配成功路径app01/，而后include功能会去app01下的urls.py中继续匹配剩余的路径部分
    url(r'^app01/', include('app01.urls')),
    url(r'^app02/', include('app02.urls')),
]

测试：

python manage.py runserver 8001  
# 在浏览器输入：http://127.0.0.1:8001/app01/index/ 会看到:我是app01的index页面...
# 在浏览器输入：http://127.0.0.1:8001/app02/index/ 会看到:我是app02的index页面...

undefined

反向解析

undefined

在软件开发初期，url地址的路径设计可能并不完美，后期须要进行调整，若是项目中不少地方使用了该路径，一旦该路径发生变化，就意味着全部使用该路径的地方都须要进行修改，这是一个很是繁琐的操做。

解决方案就是在编写一条url(regex, view, kwargs=None, name=None)时，能够经过参数name为url地址的路径部分起一个别名，项目中就能够经过别名来获取这个路径。之后不管路径如何变化别名与路径始终保持一致。

上述方案中经过别名获取路径的过程称为反向解析

案例：登陆成功跳转到index.html页面

在urls.py文件中

from django.conf.urls import url
from django.contrib import admin
from app01 import views
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    
    url(r'^login/$', views.login,name='login_page'), # 路径login/的别名为login_page
    url(r'^index/$', views.index,name='index_page'), # 路径index/的别名为index_page
]

在views.py中

from django.shortcuts import render 
from django.shortcuts import reverse # 用于反向解析
from django.shortcuts import redirect #用于重定向页面
from django.shortcuts import HttpResponse

def login(request):
    if request.method == 'GET':
        # 当为get请求时，返回login.html页面,页面中的{% url 'login_page' %}会被反向解析成路径：/login/
        return render(request, 'login.html')
    
    # 当为post请求时，能够从request.POST中取出请求体的数据
    name = request.POST.get('name')
    pwd = request.POST.get('pwd')
    if name == 'kevin' and pwd == '123':
        url = reverse('index_page')  # reverse会将别名'index_page'反向解析成路径：/index/       
        return redirect(url) # 重定向到/index/
    else:
        return HttpResponse('用户名或密码错误')


def index(request):
    return render(request, 'index.html')

login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登陆页面</title>
</head>
<body>
<!--强调：login_page必须加引号-->
<form action="{% url 'login_page' %}" method="post">
    {% csrf_token %} <!--强调：必须加上这一行，后续咱们会详细介绍-->
    <p>用户名：<input type="text" name="name"></p>
    <p>密码：<input type="password" name="pwd"></p>
    <p><input type="submit" value="提交"></p>

</form>
</body>
</html>

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>首页</title>
</head>
<body>
<h3>我是index页面...</h3>
</body>
</html>

测试：

python manage.py runserver 8001  
# 在浏览器输入：http://127.0.0.1:8001/login/ 会看到登陆页面，输入正确的用户名密码会跳转到index.html
# 当咱们修改路由表中匹配路径的正则表达式时，程序其他部分均无需修改

总结：

在views.py中，反向解析的使用：
    url = reverse('index_page')
在模版login.html文件中，反向解析的使用
    {% url 'login_page' %}

拓展阅读

若是路径存在分组的反向解析使用：

from django.conf.urls import url
from django.contrib import admin
from app01 import views
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    
    url(r'^aritcle/(\d+)/$',views.article,name='article_page'), #　无名分组
    url(r'^user/(?P<uid>\d+)/$',views.article,name='user_page'), # 有名分组
]
# 1 针对无名分组，好比咱们要反向解析出：/aritcle/1/ 这种路径，写法以下
在views.py中，反向解析的使用：
    url = reverse('article_page',args=(1,)) 
在模版login.html文件中，反向解析的使用
    {% url 'article_page' 1 %}

    
# 2 针对有名分组，好比咱们要反向解析出：/user/1/ 这种路径，写法以下
在views.py中，反向解析的使用：
    url = reverse('user_page',kwargs={'uid':1}) 
在模版login.html文件中，反向解析的使用
    {% url 'user_page' uid=1 %}

名称空间

undefined

当咱们的项目下建立了多个app，而且每一个app下都针对匹配的路径起了别名，若是别名存在重复，那么在反向解析时则会出现覆盖，以下

  1. 建立两个app
# 新建项目mystie2
E:\git>django-admin startproject mysite2
# 切换到项目目录下
E:\git>cd mysite2
# 建立app01和app02
E:\git\mysite2>python3 manage.py startapp app01
E:\git\mysite2>python3 manage.py startapp app02
  1. 在每一个app下手动建立urls.py来存放本身的路由，而且为匹配的路径起别名

app01下的urls.py文件

from django.conf.urls import url
from app01 import views

urlpatterns = [
    # 为匹配的路径app01/index/起别名'index_page'
    url(r'^index/$',views.index,name='index_page'), 
]

app02下的urls.py文件

from django.conf.urls import url
from app02 import views

urlpatterns = [
    # 为匹配的路径app02/index/起别名'index_page',与app01中的别名相同
    url(r'^index/$',views.index,name='index_page'), 
]
  1. 在每一个app下的view.py中编写视图函数，在视图函数中针对别名'index_page'作反向解析

app01下的views.py

from django.shortcuts import render
from django.shortcuts import HttpResponse
from django.shortcuts import reverse

def index(request):
    url=reverse('index_page')
    return HttpResponse('app01的index页面，反向解析结果为%s' %url)

app02下的views.py

from django.shortcuts import render
from django.shortcuts import HttpResponse
from django.shortcuts import reverse

def index(request):
    url=reverse('index_page')
    return HttpResponse('app02的index页面，反向解析结果为%s' %url)
  1. 在总的urls.py文件中（mysite2文件夹下的urls.py）
from django.conf.urls import url,include
from django.contrib import admin

# 总路由表
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    
    # 新增两条路由，注意不能以$结尾
    url(r'^app01/', include('app01.urls')),
    url(r'^app02/', include('app02.urls')),
]

四、测试：

python manage.py runserver 8001

在测试时，不管在浏览器输入：http://127.0.0.1:8001/app01/index/仍是输入http://127.0.0.1:8001/app02/index/ 针对别名'index_page'反向解析的结果都是/app02/index/，覆盖了app01下别名的解析。

undefined

解决这个问题的方法之一就是避免使用相同的别名，若是就想使用相同的别名，那就须要用到django中名称空间的概念，将别名放到不一样的名称空间中，这样即使是出现重复，彼此也不会冲突，具体作法以下

  1. 总urls.py在路由分发时，指定名称空间
from django.conf.urls import url, include
from django.contrib import admin

# 总路由表
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    
    # 传给include功能一个元组，元组的第一个值是路由分发的地址，第二个值则是咱们为名称空间起的名字
    url(r'^app01/', include(('app01.urls','app01'))),
    url(r'^app02/', include(('app02.urls','app02'))),
]
  1. 修改每一个app下的view.py中视图函数，针对不一样名称空间中的别名'index_page'作反向解析

app01下的views.py

from django.shortcuts import render
from django.shortcuts import HttpResponse
from django.shortcuts import reverse

def index(request):
    url=reverse('app01:index_page') # 解析的是名称空间app01下的别名'index_page'
    return HttpResponse('app01的index页面，反向解析结果为%s' %url)

app02下的views.py

from django.shortcuts import render
from django.shortcuts import HttpResponse
from django.shortcuts import reverse

def index(request):
    url=reverse('app02:index_page') # 解析的是名称空间app02下的别名'index_page'
    return HttpResponse('app02的index页面，反向解析结果为%s' %url)
  1. 测试：
python manage.py runserver 8001

浏览器输入：http://127.0.0.1:8001/app01/index/反向解析的结果是/app01/index/

在浏览器输入http://127.0.0.1:8001/app02/index/ 反向解析的结果是/app02/index/

总结+补充

一、在视图函数中基于名称空间的反向解析，用法以下
url=reverse('名称空间的名字:待解析的别名')

二、在模版里基于名称空间的反向解析，用法以下
<a href="{% url '名称空间的名字:待解析的别名'%}">哈哈</a>

django2.0版的re_path与path

re_path

Django2.0中的re_path与django1.0的url同样，传入的第一个参数都是正则表达式

from django.urls import re_path # django2.0中的re_path
from django.conf.urls import url # 在django2.0中一样能够导入1.0中的url

urlpatterns = [
    # 用法彻底一致
    url(r'^app01/', include(('app01.urls','app01'))),
    re_path(r'^app02/', include(('app02.urls','app02'))),
]

path

在Django2.0中新增了一个path功能，用来解决：数据类型转换问题与正则表达式冗余问题，以下

urls.py文件

from django.urls import re_path

from app01 import views

urlpatterns = [
    # 问题一：数据类型转换
    # 正则表达式会将请求路径中的年份匹配成功而后以str类型传递函数year_archive，在函数year_archive中若是想以int类型的格式处理年份，则必须进行数据类型转换
    re_path(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),

    # 问题二：正则表达式冗余
    # 下述三个路由中匹配article_id采用了一样的正则表达式，重复编写了三遍，存在冗余问题，而且极不容易管理，由于一旦article_id规则须要改变，则必须同时修改三处代码
    
    re_path(r'^article/(?P<article_id>[a-zA-Z0-9]+)/detail/$', views.detail_view),
    re_path(r'^articles/(?P<article_id>[a-zA-Z0-9]+)/edit/$', views.edit_view),
    re_path(r'^articles/(?P<article_id>[a-zA-Z0-9]+)/delete/$', views.delete_view),
]

views.py

from django.shortcuts import render,HttpResponse

# Create your views here.
def year_archive(request,year):
    print(year,type(year))
    return HttpResponse('year_archive page')

def detail_view(request,article_id):
    print(article_id, type(article_id))
    return HttpResponse('detail_view page')

def edit_view(request,article_id):
    print(article_id, type(article_id))
    return HttpResponse('edit_view page')

def delete_view(request,article_id):
    print(article_id, type(article_id))
    return HttpResponse('delete_view page')

undefined

Django2.0中的path如何解决上述两个问题的呢？请看示例

from django.urls import path,re_path

from app01 import views

urlpatterns = [
    # 问题一的解决方案：
    path('articles/<int:year>/', views.year_archive), # <int:year>至关于一个有名分组，其中int是django提供的转换器，至关于正则表达式，专门用于匹配数字类型，而year则是咱们为有名分组命的名，而且int会将匹配成功的结果转换成整型后按照格式（year=整型值）传给函数year_archive


    # 问题二解决方法：用一个int转换器能够替代多处正则表达式
    path('articles/<int:article_id>/detail/', views.detail_view), 
    path('articles/<int:article_id>/edit/', views.edit_view),
    path('articles/<int:article_id>/delete/', views.delete_view),
]

强调：

#一、path与re_path或者1.0中的url的不一样之处是，传给path的第一个参数再也不是正则表达式，而是一个彻底匹配的路径，相同之处是第一个参数中的匹配字符均无需加前导斜杠

#二、使用尖括号(<>)从url中捕获值，至关于有名分组

#三、<>中能够包含一个转化器类型（converter type），好比使用 <int:name> 使用了转换器int。若果没有转化器，将匹配任何字符串，固然也包括了 / 字符

undefined

django默认支持一下5种转换器（Path converters）

str,匹配除了路径分隔符（/）以外的非空字符串，这是默认的形式
int,匹配正整数，包含0。
slug,匹配字母、数字以及横杠、下划线组成的字符串。
uuid,匹配格式化的uuid，如 075194d3-6885-417e-a8a8-6c931e272f00。
path,匹配任何非空字符串，包含了路径分隔符（/）（不能用？）

例如

path('articles/<int:year>/<int:month>/<slug:other>/', views.article_detail) 
# 针对路径http://127.0.0.1:8000/articles/2009/123/hello/，path会匹配出参数year=2009,month=123,other='hello'传递给函数article_detail

很明显针对月份month，转换器int是没法精准匹配的，若是咱们只想匹配两个字符，那么转换器slug也没法知足需求，针对等等这一系列复杂的须要，咱们能够定义本身的转化器。转化器是一个类或接口，它的要求有三点：

  • regex 类属性，字符串类型
  • to_python(self, value) 方法，value是由类属性 regex 所匹配到的字符串，返回具体的Python变量值，以供Django传递到对应的视图函数中。
  • to_url(self, value) 方法，和 to_python 相反，value是一个具体的Python变量值，返回其字符串，一般用于url反向引用。

自定义转换器示例：

  1. 在app01下新建文件path_ converters.py,文件名能够随意命名

    class MonthConverter:
    regex='\d{2}' # 属性名必须为regex

    def to_python(self, value):
        return int(value)

    def to_url(self, value):
        return value # 匹配的regex是两个数字，返回的结果也必须是两个数字

  2. 在urls.py中，使用register_converter 将其注册到URL配置中：

    from django.urls import path,register_converter
from app01.path_converts import MonthConverter

register_converter(MonthConverter,'mon')

from app01 import views


urlpatterns = [
    path('articles/<int:year>/<mon:month>/<slug:other>/', views.article_detail, name='aaa'),

]

  3. views.py中的视图函数article_detail

    from django.shortcuts import render,HttpResponse,reverse

def article_detail(request,year,month,other):
    print(year,type(year))
    print(month,type(month))
    print(other,type(other))
    print(reverse('xxx',args=(1988,12,'hello'))) # 反向解析结果/articles/1988/12/hello/
    return HttpResponse('xxxx')

  4. 测试

    # 一、在浏览器输入http://127.0.0.1:8000/articles/2009/12/hello/，path会成功匹配出参数year=2009,month=12,other='hello'传递给函数article_detail
# 二、在浏览器输入http://127.0.0.1:8000/articles/2009/123/hello/，path会匹配失败，由于咱们自定义的转换器mon只匹配两位数字，而对应位置的123超过了2位
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程