通过Django 与 PostgreSQL 进行WEB开发详细流程

1. 项目与应用的创建及基本结构配置

1.1 创建 Django 项目和应用

在开始之前，确保已安装 Django。可以用以下命令确认：

bash 复制代码

pip install django

然后，使用以下命令创建一个新的 Django 项目：

bash 复制代码

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

执行完这两条命令后，Django 会生成如下目录结构：

bash 复制代码

myproject/
│
├── manage.py
├── myproject/
│   ├── __init__.py
│   ├── asgi.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
│
└── myapp/
    ├── migrations/
    │   └── __init__.py
    ├── __init__.py
    ├── admin.py
    ├── apps.py
    ├── models.py
    ├── tests.py
    └── views.py

1.2 Django 项目目录结构解析

项目根目录（myproject）：
- manage.py：一个项目管理工具，用于管理 Django 项目，执行命令行操作，如启动开发服务器、数据库迁移等。
项目主目录（myproject/myproject/）：
- __init__.py：将 myproject 目录识别为 Python 包，使得可以导入该目录内的模块。
- asgi.py：ASGI（异步服务器网关接口）配置文件，主要用于配置异步服务器，可以选择性支持 WebSocket。
- settings.py：Django 项目的主配置文件，定义了数据库连接、应用程序注册、静态文件路径、模板路径等。
- urls.py：项目的 URL 配置文件，定义 URL 路由，通过 include() 函数可以加载各个应用的路由。
- wsgi.py：WSGI（Web服务器网关接口）配置文件，用于部署时与 Web 服务器（如 Apache、Nginx）连接。
应用目录（myproject/myapp/）：
- migrations/：迁移文件夹，保存数据库迁移文件，Django 在数据库模式更改时会生成的迁移文件。
- __init__.py：将 myapp 目录识别为 Python 包。
- admin.py：用于 Django 管理后台的配置，可以在这里注册模型，使模型在 Django 管理后台中管理。
- apps.py：用于应用的配置，指定应用的名称等信息。
- models.py：模型定义文件，存储数据库的表结构，用于定义应用中的数据模型类。
- tests.py：测试文件，用于编写测试代码，以验证应用功能。
- views.py：视图文件，处理客户端请求并返回相应的响应。

1.3 创建并配置静态文件夹 `static` 和模板文件夹 `templates`

接下来，我们创建 static 和 templates 文件夹，用于存放静态资源文件和模板文件。

创建静态文件夹 static ：在项目根目录下创建一个 static 文件夹，并可以根据需要创建子文件夹来组织 CSS、JavaScript 等文件：

bash 复制代码

myproject/
│
├── static/
│   ├── css/
│   │   └── style.css
│   └── js/
│       └── script.js

static 文件夹 ：存储 CSS、JavaScript、图片等静态资源，Django 会自动识别 static 中的文件，在项目设置中指定路径即可使用。

创建模板文件夹 templates ：在项目根目录创建 templates 文件夹，并可以创建不同应用的模板文件：

bash 复制代码

myproject/
│
├── templates/
│   └── myapp/
│       └── home.html

templates 文件夹 ：存储 HTML 文件，Django 使用 templates 文件夹中的 HTML 文件渲染网页内容。可以在应用文件夹下再创建一个 templates 文件夹，项目中若存在多个应用，按应用组织模板便于维护。

2. 数据库配置与模型定义

2.1 安装 PostgreSQL 驱动程序

Django 需要 psycopg2 驱动程序来与 PostgreSQL 数据库通信。可以使用以下命令安装：

bash 复制代码

pip install psycopg2

安装完成后，为确保安装成功并正确连接数据库，可以进行验证：

方法 1：使用 Python 交互模式验证

在终端中输入 python 启动 Python 交互模式。
逐行输入以下代码，或者直接粘贴全部代码：

python 复制代码

import psycopg2

try:
    connection = psycopg2.connect(
        dbname="your_db_name",
        user="your_db_user",
        password="your_db_password",
        host="localhost",
        port="5432"
    )
    print("数据库连接成功")
    connection.close()
except Exception as e:
    print("数据库连接失败:", e)

方法 2：创建一个脚本文件验证

在项目根目录（包含 manage.py 的目录）下创建一个 test_db_connection.py 文件，将上面的代码粘贴进去并保存。然后执行以下命令运行脚本：

bash 复制代码

python test_db_connection.py

无论是使用哪种方式，成功时会看到 "数据库连接成功"，否则会显示具体的错误信息。

2.2 配置 `settings.py` 文件的数据库连接

打开项目配置目录下的 settings.py 文件（一般位于 myproject/settings.py），找到 DATABASES 设置部分，并将其修改为 PostgreSQL 数据库的连接信息，如下：

python 复制代码

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'your_db_name',       # 替换为你的数据库名称
        'USER': 'your_db_user',        # 替换为你的数据库用户
        'PASSWORD': 'your_db_password', # 替换为你的数据库密码
        'HOST': 'localhost',           # 数据库主机（本地开发使用 localhost）
        'PORT': '5432',                # PostgreSQL 默认端口
    }
}

确保 PostgreSQL 数据库服务正在运行，并且已创建了指定名称的数据库和用户。

2.3 创建模型（`models.py`）

在 Django 中，模型类用于定义数据库表结构。每个模型类通常对应数据库中的一张表，而类中的字段对应表的列。打开你的应用目录下的 models.py 文件（如 myapp/models.py），在里面定义模型类和字段。

示例：创建一个简单的模型

我们创建一个 Book 模型，表示图书表，并包含以下字段：

title：书名，字符类型
author：作者，字符类型
published_date：发布日期，日期类型
price：价格，浮点数

在 myapp/models.py 文件中，定义如下：

python 复制代码

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=200)         # 书名字段，最大长度 200
    author = models.CharField(max_length=100)        # 作者字段，最大长度 100
    published_date = models.DateField()              # 发布日期字段，日期类型
    price = models.DecimalField(max_digits=5, decimal_places=2)  # 价格字段，浮点数，精度两位小数

    def __str__(self):
        return self.title  # 返回书名，便于在管理界面中显示

字段类型和约束

CharField：字符类型，max_length 指定最大长度。
DateField：日期类型，存储年-月-日。
DecimalField：用于存储小数，max_digits 表示总位数，decimal_places 表示小数位数。
__str__ 方法：返回对象的字符串表示，一般用于 Django 管理界面中展示。

2.4 数据库迁移

在定义好模型后，需要进行迁移操作，将模型同步到数据库中：

1.生成迁移文件

运行以下命令生成迁移文件：

bash 复制代码

python manage.py makemigrations

Django 会在 migrations 目录下创建迁移文件，记录模型的更改。

2.执行迁移命令

运行以下命令，将模型应用到数据库中，创建对应的表：

bash 复制代码

python manage.py migrate

该命令会根据迁移文件中的内容在数据库中生成表和字段。

3.确认数据库中的表结构

连接到 PostgreSQL 数据库，查看生成的表结构。可以通过 psql 或 pgAdmin 工具来验证。

3. URL 路由配置

在 Django 中，URL 路由配置用于定义用户访问不同 URL 时，项目应该执行的视图逻辑。Django 通过 urls.py 文件来实现路由管理，主要包括应用内的 URL 路由配置和项目根目录的 URL 配置。

3.1 应用内的 URL 配置

每个应用可以有自己的 urls.py 文件，用于定义应用内的 URL 路由。通常在创建应用时，Django 不会自动生成该文件，因此需要手动创建。

1.在应用文件夹（myapp）中创建 urls.py 文件

2.定义应用内的路由

打开 myapp/urls.py，编写路由规则。Django 使用 path() 函数来定义 URL 路径，包含路径名称和调用的视图函数。以下示例中定义了一个主页和一个关于页面的路由。

python 复制代码

# myapp/urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('', views.home, name='home'),            # 主页
    path('about/', views.about, name='about'),    # 关于页面
]

path()：用于定义 URL 路径。第一个参数是路径字符串，第二个参数是视图函数，name 参数用于在模板中引用此路由。
views.home 和 views.about：指向 views.py 文件中的 home 和 about 视图函数，这些函数会处理该 URL 请求。

3.定义视图函数

确保在 myapp/views.py 中定义了与 URL 路由对应的视图函数。例如：

python 复制代码

# myapp/views.py
from django.http import HttpResponse

def home(request):
    return HttpResponse("Welcome to the Home Page")

def about(request):
    return HttpResponse("This is the About Page")

3.2 项目根 URL 配置

项目根目录的 urls.py（通常在 myproject/urls.py）文件用于包含项目中所有应用的路由。这样可以让 Django 在接收到请求时找到相应的应用 URL。

修改项目根 URL 配置 ：打开 myproject/urls.py 文件，使用 include() 函数将应用的 urls.py 文件引入项目的 URL 配置。

python 复制代码

# myproject/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),                # Django 管理后台
    path('', include('myapp.urls')),                # 包含 myapp 的 URL 路由
]

注意：include() 函数用于将其他 URL 路由文件包含进来，是 Django 路由分离和组织的重要方式。

path('admin/', admin.site.urls)：将 admin/ URL 指向 Django 的默认管理后台。
path('', include('myapp.urls'))：使用 include() 函数将 myapp 的 URL 路由包含进来。这里的 '' 表示 myapp 的路由在根路径下生效。

3.3 配置的实际效果验证

配置完 URL 路由后，可以启动 Django 开发服务器来验证配置效果。

1.启动开发服务器 ：在项目根目录（包含 manage.py 的目录）下执行以下命令启动服务器：

bash 复制代码

python manage.py runserver

启动成功后，服务器会在默认的 http://127.0.0.1:8000 运行。

2.测试 URL 路由：

在浏览器中访问 http://127.0.0.1:8000/，应能看到 home 视图返回的内容（如 "Welcome to the Home Page"）。
访问 http://127.0.0.1:8000/about/，应能看到 about 视图返回的内容（如 "This is the About Page"）。

3.常见问题排查：

如果 URL 无法正确匹配，请检查 urls.py 中的路径和视图函数名称是否拼写正确。
如果遇到 404 错误，检查项目根 URL 配置是否包含应用的 URL 路由。

4. 视图文件（views.py）的配置

视图是 Django 中处理用户请求的核心部分。views.py 文件中的视图函数或视图类负责接收请求、处理逻辑、访问数据库或其他数据源，并将结果返回给用户。可以使用 函数视图 和 类视图 两种方式来定义视图。

函数视图和类视图的渲染结果在浏览器中是一致的，只是实现方式不同：

函数视图：适合简单的业务逻辑，直接用一个函数处理请求并返回响应。
类视图 ：适合更复杂或通用的功能需求，支持继承和代码复用，可以减少重复代码。例如，当需要创建、读取、更新、删除（CRUD）功能时，类视图的通用视图如 ListView、DetailView 会更简洁高效。

4.1 视图文件的作用及用途

作用：views.py 文件用于定义视图逻辑，决定如何响应客户端请求。

用途：

处理请求：视图接收来自用户的 HTTP 请求（如 GET、POST 请求）。
执行业务逻辑：视图可以执行各种业务逻辑，如查询数据库、进行计算或调用第三方 API。
返回响应：视图将处理后的结果通过 HTTP 响应返回给用户，可以是纯文本、HTML 模板、JSON 数据等。

4.2 使用函数视图加载模板并渲染数据

在 views.py 中可以这样定义一个函数视图来渲染模板：

python 复制代码

# views.py
from django.shortcuts import render

def home(request):
    context = {
        'title': "主页",
        'message': "欢迎访问我们的网站！"
    }
    return render(request, 'home.html', context)

render() 函数接收三个参数：request（请求对象）、模板路径（如 'home.html'）和上下文数据（如 context 字典）。
这个函数视图会将 context 中的数据传递给模板 home.html，模板文件会渲染 title 和 message 的内容。

4.3 使用类视图加载模板并渲染数据

类视图同样可以加载模板并渲染相同的数据。这里使用 TemplateView 来实现：

python 复制代码

# views.py
from django.views.generic import TemplateView

class HomeView(TemplateView):
    template_name = "home.html"  # 指定模板文件路径

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['title'] = "主页"
        context['message'] = "欢迎访问我们的网站！"
        return context

template_name：指定要渲染的模板文件路径。
get_context_data()：定义上下文数据，并将 title 和 message 传递到模板中。get_context_data() 返回的 context 会自动传递给模板。

4.4 在 URL 路由中调用视图

无论是函数视图还是类视图，都可以在 URL 路由中调用，并实现相同的效果。

python 复制代码

# urls.py
from django.urls import path
from .views import home, HomeView

urlpatterns = [
    path('function/', home, name='function_home'),            # 使用函数视图
    path('class/', HomeView.as_view(), name='class_home'),    # 使用类视图
]

访问 http://127.0.0.1:8000/function/ 会调用函数视图 home 并渲染 home.html。
访问 http://127.0.0.1:8000/class/ 会调用类视图 HomeView 并渲染相同的 home.html。

5. 静态文件与模板的配置

在 Django 中，静态文件（如 CSS、JavaScript 和图片）和模板（HTML 文件）分别存储和渲染页面的样式、脚本和内容。Django 允许通过配置 settings.py 文件来管理静态文件和模板路径，以便在项目中加载、引用和组织它们。

5.1 在 `settings.py` 中配置静态文件与模板文件路径

在**settings.py** 中，Django 提供了 STATICFILES_DIRS 和 TEMPLATES 配置，用于指定静态文件和模板文件的路径。

1. 配置静态文件路径：STATICFILES_DIRS

静态文件是项目中的固定资源，如 CSS、JavaScript 和图片文件。STATICFILES_DIRS 是一个列表，用于指定额外的静态文件目录。

示例：在项目根目录创建一个 static 文件夹，用于存放全局的静态文件。

python 复制代码

# settings.py

# 静态文件的基本配置
STATIC_URL = '/static/'  # 用于引用静态文件的 URL 前缀

# 额外的静态文件目录
STATICFILES_DIRS = [
    BASE_DIR / "static",  # 指定全局静态文件目录
]

解释：

STATIC_URL：设置静态文件的 URL 前缀。通常设为 /static/，用于生成静态文件的 URL。
STATICFILES_DIRS：用于定义额外的静态文件目录，通常是项目根目录下的 static 文件夹。Django 会从这些目录中查找和加载静态文件。

例如，如果有一个 CSS 文件位于 static/css/style.css，最终可以通过 http://127.0.0.1:8000/static/css/style.css 访问它。

2. 配置模板文件路径：TEMPLATES

Django 使用 TEMPLATES 配置项指定模板的加载路径。TEMPLATES 是一个列表，每个元素是一个字典，定义模板相关的设置。

示例：在项目根目录创建一个 templates 文件夹，用于存放全局模板文件。

python 复制代码

# settings.py

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',  # 使用 Django 的模板引擎
        'DIRS': [BASE_DIR / "templates"],  # 全局模板目录
        'APP_DIRS': True,  # 自动查找各应用的 templates 文件夹
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

解释：

DIRS：指定全局模板目录，这里设置为项目根目录下的 templates 文件夹。Django 会优先从这个目录中加载模板。
APP_DIRS：如果设置为 True，Django 会自动查找各应用的 templates 文件夹，这样每个应用都可以有独立的模板文件。
context_processors：上下文处理器配置，用于在模板中全局提供某些变量或功能。

5.2 加载和引用静态文件与模板

在 HTML 模板中，可以使用 Django 模板语言中的 {% static %} 标签加载静态文件，使用 {% include %} 标签引用其他模板，方便组织和管理不同应用的模板文件。

1. 加载静态文件

在 Django 模板中，使用 {% static %} 标签生成静态文件的 URL。首先，需要在模板文件的顶部加载 static 模板标签库。

示例：加载一个 CSS 文件

css 复制代码

<!-- templates/base.html -->
{% load static %}  <!-- 加载 static 标签库 -->

<!DOCTYPE html>
<html>
<head>
    <title>My Website</title>
    <link rel="stylesheet" href="{% static 'css/style.css' %}">  <!-- 引用静态文件 -->
</head>
<body>
    <h1>欢迎来到我的网站！</h1>
</body>
</html>

{% load static %}：引入 static 标签库。
{% static 'css/style.css' %}：生成静态文件的 URL，这里引用的是 static/css/style.css 文件。

2. 组织不同应用的模板文件路径

在项目中，每个应用可以拥有自己的 templates 文件夹，用于存放独立的模板文件。启用 APP_DIRS 后，Django 会自动在每个应用的 templates 文件夹中查找模板文件。

示例：在应用 myapp 中组织模板文件

创建应用模板文件夹结构：

css 复制代码

myproject/
├── myapp/
│   └── templates/
│       └── myapp/
│           └── home.html

在 home.html 模板中加载静态文件：

html 复制代码

<!-- myapp/templates/myapp/home.html -->
{% load static %}

<!DOCTYPE html>
<html>
<head>
    <title>Home</title>
    <link rel="stylesheet" href="{% static 'css/style.css' %}">
</head>
<body>
    <h1>欢迎来到我的应用！</h1>
</body>
</html>

在 views.py 中加载并渲染 home.html 模板：

python 复制代码

# myapp/views.py
from django.shortcuts import render

def home(request):
    return render(request, 'myapp/home.html')

在 views.py 中，使用相对路径 'myapp/home.html' 加载模板。
Django 会自动在 myapp/templates/myapp 中查找 home.html 文件。

静态文件 ：配置 STATIC_URL 和 STATICFILES_DIRS，并在模板中使用 {% static %} 标签引用静态文件。

模板文件 ：配置 TEMPLATES 的 DIRS 指向全局模板路径，并开启 APP_DIRS 以支持应用独立模板。使用 {% include %} 等标签可以在不同模板之间引用内容。

6. 配置 `settings.py` 文件的其他设置项

settings.py 文件是 Django 项目的核心配置文件，包含了项目运行所需的各种设置。除了数据库、静态文件和模板配置外，还有一些其他重要的设置项需要关注。

6.1 调试模式与密钥配置

1. 调试模式：DEBUG

作用：DEBUG 设置控制项目的调试模式。在开发环境中通常设置为 True，以便在出现错误时看到详细的调试信息和堆栈跟踪。在生产环境中应设置为 False，以防止泄露敏感信息。

配置示例：

python 复制代码

# settings.py

DEBUG = True  # 开发模式，开启调试

DEBUG = True：启用调试模式。出现错误时，Django 会显示详细的错误页面，方便开发调试。
DEBUG = False：禁用调试模式。在生产环境中使用，错误页面会显示一个通用的错误信息，而不会暴露详细的堆栈信息。

2. 密钥配置：SECRET_KEY

作用：SECRET_KEY 是 Django 项目的安全密钥，用于加密会话（Session）、CSRF 令牌等安全相关的操作。密钥必须是一个足够复杂的随机字符串，并且需要保密。

配置示例：

python 复制代码

# settings.py

SECRET_KEY = 'your-secret-key-here'

重要性 ：SECRET_KEY 一旦泄露，可能导致安全漏洞，如会话伪造。因此，特别是在生产环境中，密钥必须保密，并且通常从环境变量中读取，以增强安全性。

生产环境的配置示例：

python 复制代码

import os

SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY')

从环境变量中读取 SECRET_KEY，避免直接在代码中暴露。

6.2 中间件配置

作用：中间件（Middleware）是 Django 处理请求和响应的钩子机制。每个请求和响应在到达视图或返回客户端的过程中，会依次通过中间件列表中的每个中间件。中间件可以用来进行全局的处理操作，如安全验证、会话管理等。

MIDDLEWARE 设置：

python 复制代码

# settings.py

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',        # 安全中间件
    'django.contrib.sessions.middleware.SessionMiddleware', # 会话中间件
    'django.middleware.common.CommonMiddleware',            # 通用中间件
    'django.middleware.csrf.CsrfViewMiddleware',             # CSRF 防护中间件
    'django.contrib.auth.middleware.AuthenticationMiddleware', # 认证中间件
    'django.contrib.messages.middleware.MessageMiddleware', # 消息中间件
    'django.middleware.clickjacking.XFrameOptionsMiddleware', # 点击劫持防护中间件
]

示例中间件解释：

SecurityMiddleware：为请求/响应添加安全相关的处理，如强制 HTTPS（在生产环境中启用）。
SessionMiddleware：管理用户会话数据，通过浏览器的会话保存和读取信息。
CommonMiddleware：提供一些常见的 HTTP 功能，如 URL 尾部斜杠的处理。
CsrfViewMiddleware：用于防止跨站请求伪造（CSRF）攻击，确保提交的请求来自可信来源。
AuthenticationMiddleware ：处理用户身份验证和权限检查，使 request.user 在视图中可用。
MessageMiddleware：管理临时消息，如表单提交的成功/失败信息。
XFrameOptionsMiddleware：防御点击劫持（clickjacking）攻击，防止网站被嵌入到 iframe 中。

中间件按顺序应用于每个请求和响应，通过调整 MIDDLEWARE 列表中的顺序可以改变处理顺序。

6.3 应用注册

作用：INSTALLED_APPS 列表用于注册 Django 项目中的应用（app）和第三方库，以便 Django 加载这些应用的模型、信号、管理界面等功能。所有在项目中使用的应用都必须在 INSTALLED_APPS 中注册。

示例：

python 复制代码

# settings.py

INSTALLED_APPS = [
    'django.contrib.admin',              # 管理后台
    'django.contrib.auth',               # 认证系统
    'django.contrib.contenttypes',       # 内容类型框架
    'django.contrib.sessions',           # 会话管理
    'django.contrib.messages',           # 消息框架
    'django.contrib.staticfiles',        # 静态文件管理

    # 自定义应用
    'myapp',                             # 注册自定义应用 myapp

    # 第三方库
    'rest_framework',                    # Django REST framework
]

说明：

内置应用 ：django.contrib.* 是 Django 提供的内置应用，如 auth、sessions 等。它们提供基础的功能支持。
自定义应用 ：将项目中的应用（如 myapp）添加到列表中，以便 Django 识别并加载该应用的模型和视图等。
第三方库 ：如 rest_framework，通过 pip install 安装后，需要在 INSTALLED_APPS 中注册，以启用相应功能。

6.4 时区和语言设置

作用：TIME_ZONE 和 LANGUAGE_CODE 用于配置项目的默认时区和语言，以便适应不同的地域需求。Django 会根据这些配置项对时间和文本进行本地化处理。

1. 时区设置：TIME_ZONE

作用：TIME_ZONE 设置项目的默认时区，Django 会根据该时区处理时间数据。

示例：

python 复制代码

# settings.py

TIME_ZONE = 'Asia/Shanghai'  # 设置为中国时区
USE_TZ = True                # 启用时区支持

TIME_ZONE ：指定项目的时区，如 'Asia/Shanghai' 表示中国时区。Django 的默认时区是 'UTC'。
USE_TZ ：设置为 True 启用时区支持，Django 会将所有时间数据存储为 UTC，并在显示时转换为本地时区。

2. 语言设置：LANGUAGE_CODE

作用：LANGUAGE_CODE 设置项目的默认语言。Django 会根据该语言加载对应的翻译文件和本地化内容。

示例：

python 复制代码

# settings.py

LANGUAGE_CODE = 'zh-hans'  # 设置为简体中文

LANGUAGE_CODE ：指定项目的默认语言，如 'zh-hans' 表示简体中文，'en-us' 表示美国英语。Django 默认语言是 'en-us'。
当 LANGUAGE_CODE 设置为非英语时，Django 会尝试加载相应语言的翻译文件，显示本地化的内容。

7. 启动 Django 开发服务器

配置完成后，Django 提供了内置的开发服务器，可以快速启动项目进行本地测试。通过启动服务器，可以验证页面是否正确加载，静态文件是否有效，数据库连接是否正常等。

在项目根目录（包含 manage.py 的目录）下，通过以下命令启动 Django 开发服务器：

bash 复制代码

python manage.py runserver

说明：

默认情况下，服务器会在 http://127.0.0.1:8000/ 上运行。
如果需要使用自定义端口，可以在命令中指定端口号，例如：

bash 复制代码

python manage.py runserver 8080

启动效果：

启动成功后，终端会显示以下信息：

Watching for file changes with StatReloader

Performing system checks...

System check identified no issues (0 silenced).

November 2, 2024 - 10:00:00

Django version 4.0, using settings 'myproject.settings'

Starting development server at http://127.0.0.1:8000/

Quit the server with CONTROL-C.

打开浏览器，访问 http://127.0.0.1:8000/，应该会看到 Django 默认的欢迎页面，表示服务器启动成功。

通过Django 与 PostgreSQL 进行WEB开发详细流程

1. 项目与应用的创建及基本结构配置

1.1 创建 Django 项目和应用

1.2 Django 项目目录结构解析

1.3 创建并配置静态文件夹 static 和模板文件夹 templates

2. 数据库配置与模型定义

2.1 安装 PostgreSQL 驱动程序

2.2 配置 settings.py 文件的数据库连接

2.3 创建模型（models.py）

2.4 数据库迁移

3. URL 路由配置

3.1 应用内的 URL 配置

3.2 项目根 URL 配置

3.3 配置的实际效果验证

4. 视图文件（views.py）的配置

4.1 视图文件的作用及用途

4.2 使用函数视图加载模板并渲染数据

4.3 使用类视图加载模板并渲染数据

4.4 在 URL 路由中调用视图

5. 静态文件与模板的配置

5.1 在 settings.py 中配置静态文件与模板文件路径

5.2 加载和引用静态文件与模板

6. 配置 settings.py 文件的其他设置项

6.1 调试模式与密钥配置

6.2 中间件配置

6.3 应用注册

6.4 时区和语言设置

7. 启动 Django 开发服务器

1.3 创建并配置静态文件夹 `static` 和模板文件夹 `templates`

2.2 配置 `settings.py` 文件的数据库连接

2.3 创建模型（`models.py`）

5.1 在 `settings.py` 中配置静态文件与模板文件路径

6. 配置 `settings.py` 文件的其他设置项