O sistema de roteamento do Django, conhecido como URLconf, é o mecanismo que mapeia padrões de URL para funções de visualização (views). Ele oferece uma flexibilidade poderosa, permitindo desde mapeamentos simples até sistemas dinâmicos baseados em reflexão.

1. Mapeamento Direto

A forma mais elementar de definir uma rota é associar uma string fixa a uma função específica dentro do arquivo de configuração de URLs.

from django.urls import path
from . import views

urlpatterns = [
   path('painel/', views.dashboard),
]

2. Rotas baseadas em Expressões Regulares

Para cenários onde os caminhos possuem padrões variáveis, utiliza-se o re_path. É possível capturar valores de forma posicional ou através de grupos nomeados.

from django.urls import re_path
from . import views

urlpatterns = [
   # Captura posicional de dígitos
   re_path(r'^artigo/(\d+)/$', views.ver_artigo),
   
   # Captura nomeada (slug e id)
   re_path(r'^perfil/(?P<username>\w+)/(?P<uid>\d+)/$', views.detalhes_usuario),
]

3. Parâmetros Adicionais e Valores Padrão

É possível injetar dicionários de dados extras diretamente na definição da rota. Esses valores serão passados como argumentos para a view corespondente.

urlpatterns = [
   # Se 'versao' não for capturada na URL, o valor 'v1' é injetado por padrão
   re_path(r'^api/(?P<recurso>\w+)/$', views.processar_api, {'versao': 'v1'}),
]

4. Identificação de Rotas (Nomenclatura)

Atribuir nomes às rotas facilita a manutenção do código, permitindo a inversão de URLs (reverse lookup) sem a necessidade de codificar caminhos fixos no template ou nos redirecionamentos.

urlpatterns = [
   path('inicio/', views.home, name='url_home'),
   re_path(r'^registro/(\d+)/$', views.cadastro, name='url_registro'),
]

5. Modularização por Aplicação

Em projetos de grande escala, é recomendável descentralizar as rotas, permitindo que cada aplicativo (app) gerencie seu próprio conjunto de URLs através da função include.

from django.urls import include, path

urlpatterns = [
   path('vendas/', include('apps.vendas.urls')),
   path('suporte/', include('apps.tickets.urls')),
]

6. Implementação de Roteamento Dinâmico via Reflexão

Em casos avançados, pode-se criar um despachante centralizado que utiliza introspecção de Python para instanciar views dinamicamente com base nos segmentos da URL.

Definição no urls.py:

from django.urls import re_path
from .core import dispatcher

urlpatterns = [
   # Padrão: /app/funcao/id/
   re_path(r'^(?P<app_name>\w+)/(?P<view_name>\w+)/(?P<pk>\d+)/$', dispatcher.execute),
   # Padrão: /app/funcao/
   re_path(r'^(?P<app_name>\w+)/(?P<view_name>\w+)/$', dispatcher.execute),
   # Padrão: /app/ (assume 'index' como função padrão)
   re_path(r'^(?P<app_name>\w+)/$', dispatcher.execute, {'view_name': 'index'}),
]

Lógica do despachante (core/dispatcher.py):

import importlib
from django.http import HttpResponseNotFound, HttpResponseServerError
from django.shortcuts import redirect

def execute(request, **kwargs):
   """
   Interpreta os parâmetros da URL e invoca dinamicamente 
   a função correspondente no módulo de views do app.
   """
   target_app = kwargs.get('app_name')
   target_view = kwargs.get('view_name')

   try:
       # Importação dinâmica do módulo de views do aplicativo
       module_path = f"{target_app}.views"
       views_module = importlib.import_module(module_path)
       
       # Localização da função dentro do módulo via reflexão
       view_func = getattr(views_module, target_view)
       
       # Execução da lógica de negócio
       return view_func(request, kwargs)

   except (ImportError, AttributeError):
       return HttpResponseNotFound("<h1>Módulo ou View não encontrada</h1>")
   except Exception as err:
       # Log de erro e redirecionamento de segurança
       print(f"Erro na execução dinâmica: {err}")
       return redirect('/')