青少年编程与数学 02-009 Django 5 Web 编程 15课题、认证系统

发布于：2025-02-16 ⋅ 阅读:(198) ⋅ 点赞:(0)

青少年编程与数学 02-009 Django 5 Web 编程 15课题、认证系统

课题摘要: 本文全面介绍了Django中的认证系统，包括多种认证类型如用户名密码认证、多因素认证、证书认证、生物识别认证和令牌认证等。重点讲解了Django内置的用户名密码认证流程和组件，以及如何实现用户注册、登录和登出功能。文章还介绍了多因素认证的实现方法，特别是使用django-mfa2库的步骤。此外，探讨了数字证书的特点和作用，以及如何在Django中实现证书认证。最后，通过一个示例项目，展示了如何使用Django REST Framework和djangorestframework-simplejwt实现基于JWT的令牌认证，包括获取令牌、访问受保护资源和刷新令牌的过程。

一、认证

在计算机安全和网络通信领域，认证（Authentication）是指验证用户或实体身份的过程，即确认用户或实体是否是他们声称的那个人。认证是确保只有授权用户才能访问系统或资源的重要安全措施之一。以下是几种常见的认证类型：

  • 用户名和密码认证：这是最常用的认证方式之一。用户输入用户名和密码，系统通过验证密码是否匹配来确认用户身份。
  • 多因素认证（MFA）：除了用户名和密码之外，还需要用户提供额外的验证因素，如短信验证码、电子邮件验证码、指纹识别等。这增加了安全性，因为即使攻击者获取了用户名和密码，没有其他验证因素也无法登录。
  • 证书认证：使用数字证书进行认证。证书通常由可信的证书颁发机构（CA）签发，包含公钥和身份信息。客户端和服务器通过交换证书来验证彼此的身份。
  • 生物识别认证：通过生物特征（如指纹、面部识别、虹膜扫描等）来验证用户身份。这种方式不需要用户记住密码，但需要相应的硬件支持。
  • 令牌认证：使用一次性令牌或令牌生成器（如硬件令牌、软件令牌应用等）生成的代码进行认证。令牌通常与用户的账户绑定，确保只有拥有令牌的用户才能登录。

认证是安全系统的基础，确保只有经过验证的用户才能访问敏感数据或执行关键操作。

二、用户名和密码认证

Django中的用户名和密码认证是通过其内置的认证系统 django.contrib.auth 来实现的。以下是详细的认证流程和相关组件：

认证流程

  1. 用户提交登录信息：

    • 用户在登录表单中输入用户名和密码。

  2. 服务器端验证：

    • Django使用 authenticate() 函数来验证用户输入的用户名和密码是否正确。该函数接受用户名和密码作为参数，如果验证成功，返回一个 User 对象；否则返回 None。
    • 示例代码：
      from django.contrib.auth import authenticate

user = authenticate(username='username', password='password')

  3. 会话创建：

    • 如果 authenticate() 返回一个用户对象，说明验证成功。接下来使用 login() 函数来创建用户的会话。这个函数接受一个 HttpRequest 对象和一个认证后的 User 对象。
    • 示例代码：
      from django.contrib.auth import login

if user is not None:
    login(request, user)

  4. 用户状态维持：

    • Django使用会话框架来维持用户的登录状态。会话ID会被存储在用户的浏览器Cookie中，服务器通过这个会话ID来识别用户。

相关组件

  • 用户模型（User Model）：

    • Django提供了一个内置的用户模型 django.contrib.auth.models.User，用于存储用户的基本信息，如用户名、密码、邮箱等。
    • 可以通过 create_user() 方法创建用户，密码会被自动加密存储。

  • 认证后端（Authentication Backend）：

    • Django允许使用不同的后端来认证用户，默认使用数据库后端。可以通过自定义认证后端来支持其他认证方式，如LDAP、OAuth等。

  • 会话管理（Session Management）：

    • Django的会话管理用于跟踪用户的登录状态，通过在浏览器中存储会话ID来实现。

安全性

  • 密码加密：
    • Django默认使用PBKDF2算法对密码进行加密存储，确保密码的安全性。
  • CSRF保护：
    • Django提供了CSRF保护机制，防止跨站请求伪造攻击。

通过这些组件和流程，Django的认证系统能够有效地验证用户身份，并管理用户的登录状态，为Web应用提供基本的安全保障。

三、用户名和密码认证示例

创建一个简单的Django项目来实现用户名和密码验证，包括用户注册、登录和登出功能。以下是完整的项目示例：

步骤 1: 创建Django项目和应用

打开终端或命令提示符，执行以下命令：

django-admin startproject myproject
cd myproject
python manage.py startapp myapp

步骤 2: 配置应用

在 myproject/settings.py 文件中，添加 myapp 到 INSTALLED_APPS 列表中：

INSTALLED_APPS = [
    # ...
    'myapp',
]

步骤 3: 创建用户模型（可选）

如果需要使用自定义用户模型，可以在 myapp/models.py 中定义。这里使用Django默认的用户模型，因此不需要自定义。

步骤 4: 创建表单

在 myapp/forms.py 文件中，创建注册和登录表单：

from django import forms
from django.contrib.auth.forms import UserCreationForm, AuthenticationForm
from django.contrib.auth.models import User

class SignUpForm(UserCreationForm):
    email = forms.EmailField(max_length=254, help_text='Required. Inform a valid email address.')

    class Meta:
        model = User
        fields = ('username', 'email', 'password1', 'password2')

class LoginForm(AuthenticationForm):
    pass

步骤 5: 创建视图

在 myapp/views.py 文件中，创建注册、登录和登出视图：

from django.shortcuts import render, redirect
from django.contrib.auth import login, authenticate, logout
from django.contrib.auth.decorators import login_required
from .forms import SignUpForm, LoginForm

def signup(request):
    if request.method == 'POST':
        form = SignUpForm(request.POST)
        if form.is_valid():
            form.save()
            username = form.cleaned_data.get('username')
            raw_password = form.cleaned_data.get('password1')
            user = authenticate(username=username, password=raw_password)
            login(request, user)
            return redirect('home')
    else:
        form = SignUpForm()
    return render(request, 'signup.html', {'form': form})

def user_login(request):
    if request.method == 'POST':
        form = LoginForm(data=request.POST)
        if form.is_valid():
            user = form.get_user()
            login(request, user)
            return redirect('home')
    else:
        form = LoginForm()
    return render(request, 'login.html', {'form': form})

@login_required
def user_logout(request):
    logout(request)
    return redirect('login')

@login_required
def home(request):
    return render(request, 'home.html')

步骤 6: 创建模板

在 myapp/templates 目录下，创建以下HTML模板文件：

  • signup.html：

    <!DOCTYPE html>
<html>
<head>
    <title>Sign Up</title>
</head>
<body>
    <h2>Sign Up</h2>
    <form method="post">
        {% csrf_token %}
        {{ form.as_p }}
        <button type="submit">Sign Up</button>
    </form>
</body>
</html>

  • login.html：

    <!DOCTYPE html>
<html>
<head>
    <title>Login</title>
</head>
<body>
    <h2>Login</h2>
    <form method="post">
        {% csrf_token %}
        {{ form.as_p }}
        <button type="submit">Login</button>
    </form>
</body>
</html>

  • home.html：

    <!DOCTYPE html>
<html>
<head>
    <title>Home</title>
</head>
<body>
    <h2>Welcome, {{ user.username }}!</h2>
    <a href="{% url 'logout' %}">Logout</a>
</body>
</html>

步骤 7: 配置URLs

在 myapp/urls.py 文件中，定义应用的URLs：

from django.urls import path
from . import views

urlpatterns = [
    path('signup/', views.signup, name='signup'),
    path('login/', views.user_login, name='login'),
    path('logout/', views.user_logout, name='logout'),
    path('home/', views.home, name='home'),
]

在 myproject/urls.py 文件中，包含应用的URLs：

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('myapp.urls')),
]

步骤 8: 迁移数据库

运行以下命令来创建数据库表：

python manage.py makemigrations
python manage.py migrate

步骤 9: 运行项目

启动Django开发服务器：

python manage.py runserver

现在，你可以访问 http://127.0.0.1:8000/signup/ 进行用户注册，访问 http://127.0.0.1:8000/login/ 进行登录，登录成功后会重定向到 http://127.0.0.1:8000/home/ 页面，显示欢迎信息和登出链接。

四、多因素认证（MFA）

在Django中实现多因素认证（MFA），可以通过使用第三方库来简化开发过程。以下是使用 django-mfa 库来实现MFA的步骤：

安装 django-mfa

首先，安装 django-mfa 库。你可以通过以下命令来安装：

pip install django-mfa

配置项目

在你的Django项目的 settings.py 文件中进行以下配置：

  1. 添加应用：
    将 django_mfa 添加到 INSTALLED_APPS 列表中：

    INSTALLED_APPS = [
    # ...
    'django_mfa',
    # ...
]

  2. 添加中间件：
    在 MIDDLEWARE 列表中添加 MfaMiddleware：

    MIDDLEWARE = [
    # ...
    'django_mfa.middleware.MfaMiddleware',
    # ...
]

  3. 配置URLs：
    在项目的 urls.py 文件中包含 django_mfa 的URLs：

    urlpatterns = [
    # ...
    path('settings/', include('django_mfa.urls')),
    # ...
]

使用MFA

  • 启用MFA：
    用户可以通过扫描二维码来启用MFA。通常使用Google Authenticator等应用来生成一次性密码。
  • 登录时验证：
    在用户登录时，除了输入用户名和密码外，还需要输入MFA应用生成的一次性密码。

高级配置

  • 设置发行者名称：
    可以在 settings.py 中设置 MFA_ISSUER_NAME，该名称将显示在认证应用中。
  • 记住设备：
    可以启用 MFA_REMEMBER_MY_BROWSER 功能，使浏览器在一段时间内被信任。

通过以上步骤，你可以在Django项目中实现多因素认证，从而提高用户账户的安全性。

五、多因素认证（MFA）示例

以下是一个完整的在Django中实现多因素认证（MFA）的项目示例，使用 django-mfa2 库：

步骤 1: 创建Django项目和应用

打开终端或命令提示符，执行以下命令：

django-admin startproject myproject
cd myproject
python manage.py startapp myapp

步骤 2: 安装 django-mfa2 库

通过以下命令安装 django-mfa2：

pip install django-mfa2

步骤 3: 配置项目

在你的Django项目的 settings.py 文件中进行以下配置：

  1. 添加应用：
    将 django_mfa2 添加到 INSTALLED_APPS 列表中：

    INSTALLED_APPS = [
    # ...
    'django_mfa2',
    # ...
]

  2. 配置URLs：
    在项目的 urls.py 文件中包含 django_mfa2 的URLs：

    from django.urls import path, include

urlpatterns = [
    # ...
    path('mfa/', include('django_mfa2.urls')),
    # ...
]

步骤 4: 迁移数据库

运行以下命令来创建数据库表：

python manage.py makemigrations
python manage.py migrate

步骤 5: 创建用户模型（可选）

如果需要使用自定义用户模型，可以在 myapp/models.py 中定义。这里使用Django默认的用户模型，因此不需要自定义。

步骤 6: 创建表单

在 myapp/forms.py 文件中，创建注册和登录表单：

from django import forms
from django.contrib.auth.forms import UserCreationForm, AuthenticationForm
from django.contrib.auth.models import User

class SignUpForm(UserCreationForm):
    email = forms.EmailField(max_length=254, help_text='Required. Inform a valid email address.')

    class Meta:
        model = User
        fields = ('username', 'email', 'password1', 'password2')

class LoginForm(AuthenticationForm):
    pass

步骤 7: 创建视图

在 myapp/views.py 文件中，创建注册、登录和登出视图：

from django.shortcuts import render, redirect
from django.contrib.auth import login, authenticate, logout
from django.contrib.auth.decorators import login_required
from .forms import SignUpForm, LoginForm

def signup(request):
    if request.method == 'POST':
        form = SignUpForm(request.POST)
        if form.is_valid():
            form.save()
            username = form.cleaned_data.get('username')
            raw_password = form.cleaned_data.get('password1')
            user = authenticate(username=username, password=raw_password)
            login(request, user)
            return redirect('home')
    else:
        form = SignUpForm()
    return render(request, 'signup.html', {'form': form})

def user_login(request):
    if request.method == 'POST':
        form = LoginForm(data=request.POST)
        if form.is_valid():
            user = form.get_user()
            login(request, user)
            return redirect('mfa:home')  # 重定向到MFA的首页
    else:
        form = LoginForm()
    return render(request, 'login.html', {'form': form})

@login_required
def user_logout(request):
    logout(request)
    return redirect('login')

@login_required
def home(request):
    return render(request, 'home.html')

步骤 8: 创建模板

在 myapp/templates 目录下，创建以下HTML模板文件：

  • signup.html：

    <!DOCTYPE html>
<html>
<head>
    <title>Sign Up</title>
</head>
<body>
    <h2>Sign Up</h2>
    <form method="post">
        {% csrf_token %}
        {{ form.as_p }}
        <button type="submit">Sign Up</button>
    </form>
</body>
</html>

  • login.html：

    <!DOCTYPE html>
<html>
<head>
    <title>Login</title>
</head>
<body>
    <h2>Login</h2>
    <form method="post">
        {% csrf_token %}
        {{ form.as_p }}
        <button type="submit">Login</button>
    </form>
</body>
</html>

  • home.html：

    <!DOCTYPE html>
<html>
<head>
    <title>Home</title>
</head>
<body>
    <h2>Welcome, {{ user.username }}!</h2>
    <a href="{% url 'logout' %}">Logout</a>
</body>
</html>

步骤 9: 运行项目

启动Django开发服务器：

python manage.py runserver

现在，你可以访问 http://127.0.0.1:8000/signup/ 进行用户注册，访问 http://127.0.0.1:8000/login/ 进行登录。登录成功后，会重定向到 http://127.0.0.1:8000/mfa/ 页面，用户可以在此页面配置和管理MFA，如启用TOTP或U2F等认证方式。

六、数字证书

数字证书（Digital Certificate），也称为公钥证书（Public Key Certificate），是一种用于证明公钥所有者身份的电子文件。它在数字通信和电子商务中广泛使用，以确保数据传输的安全性和身份的真实性。以下是数字证书的主要特点和作用：

主要特点

  • 包含公钥：数字证书中包含了公钥，用于加密数据或验证数字签名。
  • 身份信息：证书中包含证书所有者（如个人、组织或设备）的身份信息，如姓名、组织名称、电子邮件地址等。
  • 有效期：证书有一个有效期，通常由颁发日期和过期日期组成。证书在过期后将不再有效。
  • 签名：证书由证书颁发机构（CA）使用其私钥进行数字签名，以证明证书的真实性和完整性。

作用

  • 身份验证：通过验证证书的签名和内容，可以确认证书所有者的身份。例如，在SSL/TLS连接中，服务器的数字证书用于验证服务器的身份，确保客户端连接到的是正确的服务器。
  • 数据加密：证书中的公钥可以用于加密数据，只有持有对应私钥的证书所有者才能解密。这在保护数据传输过程中起到关键作用。
  • 数字签名：证书所有者可以使用私钥对数据进行数字签名，然后其他人可以使用证书中的公钥验证签名的真实性，从而确保数据的完整性和不可否认性。

证书颁发机构（CA）

  • 可信第三方：证书颁发机构是一个可信的第三方组织，负责颁发和管理数字证书。它验证申请者的身份信息，并将公钥与身份信息绑定在一起，生成数字证书。
  • 证书链：在某些情况下，证书颁发机构可能会形成一个证书链。例如，根CA颁发中间CA的证书，中间CA再颁发终端实体的证书。浏览器和操作系统通常预置了根CA的证书，从而信任整个证书链。

数字证书是实现安全通信和身份验证的重要工具，在SSL/TLS、电子邮件加密、代码签名等领域都有广泛应用。

七、证书认证

在Django中实现证书认证通常涉及使用SSL/TLS证书来确保数据传输的安全性和身份验证。以下是实现证书认证的步骤：

步骤 1: 获取SSL证书

你可以从可信的证书颁发机构（CA）获取SSL证书，或者生成自签名证书用于测试。自签名证书可以通过以下命令生成：

openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes

这将生成一个私钥文件 key.pem 和一个证书文件 cert.pem。

步骤 2: 配置Django使用SSL

使用 django-sslserver 插件
  1. 安装 django-sslserver：
    pip install django-sslserver
  2. 在 settings.py 中添加 sslserver 到 INSTALLED_APPS：
    INSTALLED_APPS = [
    # ...
    'sslserver',
    # ...
]
  3. 启动Django开发服务器时使用SSL：
    python manage.py runsslserver --certificate /path/to/cert.pem --key /path/to/key.pem
    这将使Django在本地开发环境中支持HTTPS。

步骤 3: 配置Web服务器

如果你的应用将部署到生产环境中，通常需要在Web服务器（如Nginx或Apache）上配置SSL证书：

Apache配置示例
  1. 确保已安装 mod_ssl 模块。
  2. 在Apache配置文件中添加以下配置：
    <VirtualHost *:443>
    ServerName yourdomain.com
    DocumentRoot /path/to/your/django/project

    SSLEngine on
    SSLCertificateFile /path/to/cert.pem
    SSLCertificateKeyFile /path/to/key.pem

    Alias /static /path/to/static
    <Directory /path/to/static>
        Require all granted
    </Directory>

    WSGIScriptAlias / /path/to/your/django/project/wsgi.py
    <Directory /path/to/your/django/project>
        <Files wsgi.py>
            Require all granted
        </Files>
    </Directory>
</VirtualHost>
    保存配置并重启Apache。

步骤 4: 验证客户端证书（可选）

如果你需要验证客户端证书，可以在Django中配置相应的设置。例如，可以使用 VERIFY_REQUEST 函数来判断是否需要进行SSL证书验证。

通过以上步骤，你可以在Django中实现SSL证书认证，确保数据传输的安全性和用户身份的验证。

八、生物识别认证

生物识别认证是一种利用人体独特生物特征进行身份验证的技术。这些生物特征包括指纹、面部、虹膜、声纹、掌纹等。生物识别技术相比传统的密码或令牌认证方式，具有更高的安全性和不可复制性。

生物识别认证的工作原理

  1. 注册：用户向系统提供其生物特征数据，如指纹或面部图像。
  2. 存储：这些数据被转换成加密的数学模板，存储在数据库中，与原始图像完全不同。
  3. 比对：每次认证尝试时，系统会将新的生物特征数据与存储的模板进行比对，根据相似度决定是否允许访问。

生物识别技术的类型

  • 指纹识别：通过识别手指表面的纹路特征进行身份验证，技术成熟且成本较低。
  • 人脸识别：通过分析面部特征（如眼睛、鼻子、嘴巴的位置和形状）进行身份识别。
  • 虹膜识别：利用眼睛虹膜的独特图案进行身份验证。
  • 声纹识别：通过分析声音的频率和音调特征来识别身份。

应用场景

  • 金融和支付：用于银行账户登录、支付验证等，提高交易安全性。
  • 门禁系统：用于办公楼、住宅小区等场所的出入控制。
  • 智能设备：如智能手机和智能家居设备的解锁和访问控制。

优势

  • 安全性高：生物特征难以被复制或盗用。
  • 用户体验好：无需记忆复杂的密码，认证过程快速便捷。
  • 减少欺诈风险：有效防止身份盗用和冒充。

挑战与风险

  • 隐私保护：生物特征数据的存储和处理需要严格的安全措施，以防止数据泄露。
  • 技术误识别：在某些情况下，如指纹磨损或面部遮挡，可能导致识别错误。
  • 活体检测：需要有效抵御照片、视频等仿冒手段。

生物识别认证正在不断改进和发展，未来将更加注重多模态融合、非接触式识别和隐私保护等方面。

九、令牌认证

令牌认证（Token-Based Authentication）是一种身份验证机制，通过颁发令牌来验证用户身份。以下是令牌认证的详细说明：

工作原理

  1. 用户登录：

    • 用户向服务器提交用户名和密码进行登录请求。

  2. 服务器验证凭据：

    • 服务器验证用户提交的凭据（用户名和密码）。

  3. 生成令牌：

    • 验证通过后，服务器生成一个加密的令牌，通常使用 JSON Web Token (JWT) 。

  4. 颁发令牌：

    • 服务器将令牌发送给客户端，客户端可以将令牌存储在浏览器的 localStorage 或 sessionStorage 中。

  5. 使用令牌访问受保护资源：

    • 客户端在后续请求中通过 Authorization 头部携带令牌，向服务器请求受保护的资源。

  6. 验证令牌：

    • 服务器接收到客户端请求时，会对令牌进行验证，以确定令牌的有效性和合法性。

  7. 访问资源：

    • 如果令牌有效，服务器允许访问受保护的资源；否则，拒绝请求。

优势

  • 无状态性：令牌是自包含的，服务器不需要存储用户的会话信息。
  • 便携性：令牌可以跨域和跨服务器传递。
  • 安全性：令牌通常是加密的，只有持有者和服务器可以解码。
  • 有限生命周期：令牌通常有一个过期时间，到期后需要重新生成。

应用领域

  • Web应用和API安全：广泛应用于Web应用和API，以确保只有经过授权的用户才能访问特定资源。
  • 单点登录（SSO）：用户只需在初次登录时进行身份验证，之后即可无缝访问其他系统。
  • 第三方应用授权：如社交媒体平台上的第三方开发者可以使用OAuth协议获取用户授权。

令牌认证通过其灵活性和安全性，在现代网络安全中发挥着重要作用。

十、JWT认证

JSON Web Token（JWT）是一种用于双方之间安全传输信息的简洁的、URL安全的令牌标准。JWT通常用于身份验证和信息交换，广泛应用于现代Web应用和API中。以下是JWT认证的详细介绍：

结构

JWT由三部分组成，分别是Header（头部）、Payload（负载）和Signature（签名），它们之间用点（.）分隔。

  • Header（头部）：

    • 通常包含两部分：令牌的类型（这里是JWT）和所使用的签名算法（如HS256、RS256等）。
    • 示例：
      {
  "alg": "HS256",
  "typ": "JWT"
}

  • Payload（负载）：

    • 包含声明（claims），声明是关于实体（通常是用户）和其他数据的声明。
    • 声明分为三种类型：
      • Registered claims（注册声明）：预定义的声明，如iss（发行人）、exp（过期时间）、sub（主题）、aud（受众）等。
      • Public claims（公共声明）：可以自定义的声明，如用户ID、用户名等。
      • Private claims（私有声明）：为共享JWT的双方自定义的声明。
    • 示例：
      {
  "sub": "1234567890",
  "name": "John Doe",
  "iat": 1516239022
}

  • Signature（签名）：

    • 用于验证消息在传输过程中未被篡改，并且，对于使用私钥签名的令牌，还可以验证发送者的身份。
    • 签名是使用Header中指定的算法和密钥对Header和Payload进行加密的结果。

工作流程

  1. 用户登录：

    • 用户向服务器提交用户名和密码进行登录请求。

  2. 服务器验证凭据：

    • 服务器验证用户提交的凭据（用户名和密码）。

  3. 生成JWT：

    • 验证通过后，服务器生成一个JWT，包含用户信息和过期时间等。

  4. 颁发JWT：

    • 服务器将JWT发送给客户端，客户端可以将JWT存储在本地（如浏览器的localStorage）。

  5. 使用JWT访问受保护资源：

    • 客户端在后续请求中通过 Authorization 头部携带JWT，向服务器请求受保护的资源。
    • 示例：
      Authorization: Bearer <token>

  6. 验证JWT：

    • 服务器接收到客户端请求时，会对JWT进行验证，以确定JWT的有效性和合法性。

  7. 访问资源：

    • 如果JWT有效，服务器允许访问受保护的资源；否则，拒绝请求。

优势

  • 无状态和可扩展性：JWT是自包含的，服务器不需要存储用户的会话信息，这使得JWT易于扩展到多个服务器和分布式系统。
  • 安全性：JWT可以通过加密和签名来确保数据的安全性和完整性。
  • 灵活性：可以在JWT中包含任意的用户信息和声明，以满足不同的业务需求。
  • 跨域支持：JWT可以跨域传递，适用于单点登录（SSO）等场景。

安全注意事项

  • 保护密钥：确保用于签名JWT的密钥安全，不要泄露。
  • 设置合理的过期时间：避免JWT长时间有效，以减少被滥用的风险。
  • 使用HTTPS：在传输JWT时使用HTTPS，防止中间人攻击。
  • 防止重放攻击：可以通过一次性使用的nonce或时间戳来防止重放攻击。

十一、令牌认证示例

以下是一个使用Django和Django REST Framework实现令牌认证的示例项目，使用JSON Web Token（JWT）作为令牌：

步骤 1: 创建Django项目和应用

打开终端或命令提示符，执行以下命令：

django-admin startproject myproject
cd myproject
python manage.py startapp myapp

步骤 2: 安装依赖库

通过以下命令安装Django REST Framework和 djangorestframework-simplejwt：

pip install djangorestframework
pip install djangorestframework-simplejwt

步骤 3: 配置项目

在你的Django项目的 settings.py 文件中进行以下配置：

  1. 添加应用：
    将 rest_framework 和 myapp 添加到 INSTALLED_APPS 列表中：

    INSTALLED_APPS = [
    # ...
    'rest_framework',
    'myapp',
    # ...
]

  2. 配置REST Framework：
    在 settings.py 中添加REST Framework的配置：

    REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework_simplejwt.authentication.JWTAuthentication',
    ),
}

  3. 配置JWT：
    在 settings.py 中添加JWT的配置：

    from datetime import timedelta

SIMPLE_JWT = {
    'ACCESS_TOKEN_LIFETIME': timedelta(minutes=5),
    'REFRESH_TOKEN_LIFETIME': timedelta(days=1),
    'ROTATE_REFRESH_TOKENS': False,
    'BLACKLIST_AFTER_ROTATION': True,
    'ALGORITHM': 'HS256',
    'SIGNING_KEY': SECRET_KEY,
    'VERIFYING_KEY': None,
    'AUTH_HEADER_TYPES': ('Bearer',),
    'USER_ID_FIELD': 'id',
    'USER_ID_CLAIM': 'user_id',
}

步骤 4: 创建模型

在 myapp/models.py 中创建一个简单的模型：

from django.db import models
from django.contrib.auth.models import User

class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    bio = models.TextField()

步骤 5: 创建序列化器

在 myapp/serializers.py 中创建序列化器：

from rest_framework import serializers
from django.contrib.auth.models import User
from .models import Profile

class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ('id', 'username', 'email')

class ProfileSerializer(serializers.ModelSerializer):
    user = UserSerializer(read_only=True)

    class Meta:
        model = Profile
        fields = ('user', 'bio')

步骤 6: 创建视图

在 myapp/views.py 中创建视图：

from rest_framework import generics
from django.contrib.auth.models import User
from .models import Profile
from .serializers import UserSerializer, ProfileSerializer

class UserList(generics.ListCreateAPIView):
    queryset = User.objects.all()
    serializer_class = UserSerializer

class ProfileList(generics.ListCreateAPIView):
    queryset = Profile.objects.all()
    serializer_class = ProfileSerializer

步骤 7: 配置URLs

在 myapp/urls.py 文件中定义应用的URLs：

from django.urls import path
from . import views
from rest_framework_simplejwt.views import (
    TokenObtainPairView,
    TokenRefreshView,
)

urlpatterns = [
    path('users/', views.UserList.as_view(), name='user-list'),
    path('profiles/', views.ProfileList.as_view(), name='profile-list'),
    path('token/', TokenObtainPairView.as_view(), name='token_obtain_pair'),
    path('token/refresh/', TokenRefreshView.as_view(), name='token_refresh'),
]

在 myproject/urls.py 文件中包含应用的URLs：

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include('myapp.urls')),
]

步骤 8: 迁移数据库

运行以下命令来创建数据库表：

python manage.py makemigrations
python manage.py migrate

步骤 9: 运行项目

启动Django开发服务器：

python manage.py runserver

现在，你可以访问 http://127.0.0.1:8000/api/token/ 获取JWT令牌，使用用户名和密码进行登录。登录成功后，会返回一个包含 access 和 refresh 令牌的JSON响应。你可以使用 access 令牌在请求头中携带 Authorization: Bearer <token> 来访问受保护的API资源，如 http://127.0.0.1:8000/api/users/ 和 http://127.0.0.1:8000/api/profiles/ 。如果令牌过期，可以使用 refresh 令牌获取新的 access 令牌。

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布