Once_day

Once_day

关注
发信
关注(28)粉丝(399)

FullStack之Django(2)模型和后台

FullStack之Django(2)模型和后台

author: Once Day date:2022年2月13日/2024年1月31日

漫漫长路，才刚刚开始…

全系列文档请查看专栏:

参考文档:

1.数据库后端配置

详细内容可参考官方文档: 数据库 | Django 文档 | Django (djangoproject.com)

1.1 数据库基础信息

持久连接避免了在每个 HTTP 请求中重新建立与数据库的连接的开销。它们由(CONN_MAX_AGE)参数控制，该参数定义了连接的最大生命周期。它可以独立设置在每个数据库上。

默认值是 0，保留了每次请求结束时关闭数据库连接的历史行为。要启用持久连接，可将 CONN_MAX_AGE 设置为正整数秒。对于无限制的持久连接，将其设置为 None。

由于每个线程都维护自己的连接，所以你的数据库必须支持至少与你的工作线程一样多的同时连接。

有时，数据库不会被大多数视图访问，例如因为它是外部系统的数据库，或者由于缓存的原因。在这种情况下，你应该将CONN_MAX_AGE设置为一个低值，甚至 0，因为维护一个不太可能被重复使用的连接是没有意义的。这将有助于保持这个数据库的同时连接数较少。

开发服务器每处理一个请求都会创建一个新的线程，消除了持久连接的影响。在开发过程中不要启用它们。

Django 假设所有的数据库都使用 UTF-8 编码。使用其他编码可能会导致意外的行为，比如数据库中的数据在 Django 中是有效的，却出现“value too long”的错误。

1.2 SQLite3数据库

在 初识Django 文章里已经介绍过了，Django基于MTV设计模式，第一个M(model)便是模型，它负责提供逻辑和数据的接口，所谓数据便是数据库。

Django默认使用SQLite3数据库，因为Python原生支持SQLite3数据库，所以无须安装任何程序，就可以直接使用它。在学习的时候，使用SQLite3可省略很多麻烦。

mysite/settings.py配置文件里可看到详情：

# Database
# https://docs.djangoproject.com/en/4.0/ref/settings/#databases

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

上面是默认的数据库配置，其中：

  • ENGINE（引擎）：可以是django.db.backends.sqlite3、django.db.backends.postgresql、django.db.backends.mysql、django.db.backends.oracle，当然其它的也行。
  • NAME（数据库名称）：数据库的名称。如果你使用的是默认的SQLite3，那么数据库将作为一个文件将存放在你的本地机器内，此时的NAME应该是这个文件的完整绝对路径包括文件名，默认情况下该文件储存在你的项目根目录下。

使用其他数据库时将有额外的信息需要填写，这里只考虑使用SQLite3。

1.3 Postgresql数据库

Django支持PostgreSQL 12及更高版本。需要使用psycopg 3.1.8+或psycopg2 2.8.4+，尽管建议使用最新的psycopg 3.1.8+。

psycopg3有多种安装方式，这里使用二进制安装，便于调试(如果失败，可以换成纯python实现):

pip install "psycopg[binary]"

mysite/settings.py配置文件:

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql",
        "OPTIONS": {
            "service": "my_service",
            "passfile": ".my_pgpass",
        },
    }
}

.pg_service.conf数据库服务配置信息:

[my_service]
host=localhost
user=USER
dbname=NAME
port=5432

.my_pgpass密码文件信息:

localhost:5432:NAME:USER:PASSWORD

Django 的数据库连接需要以下参数：

  • client_encoding：'UTF8'。
  • default_transaction_isolation：'read committed' 默认情况下，或在连接选项中设置的值（见下文）。
  • timezone：当 USE_TZ为 True 时，默认为 'UTC，或 TIME_ZONE 为连接设置的值。当USE_TZ为 False 时，全局 TIME_ZONE 设置的值。

如果这些参数已经有了正确的值，Django 就不会为每个新的连接设置这些参数，这样可以稍微提高性能。你可以直接在 postgresql.conf 中设置它们，或者更方便地在每个数据库用户中用[ALTER ROLE]设置。

如果没有这个优化，Django 也能正常工作，但每个新的连接都会做一些额外的查询来设置这些参数。

和 PostgreSQL 本身一样，Django 默认为 READ COMMITTED 隔离级别。如果你需要更高的隔离级别，比如 REPEATABLE READ 或者 SERIALIZABLE，可以在数据库配置的DATABASES中的OPTIONS部分进行设置：

from django.db.backends.postgresql.psycopg_any import IsolationLevel

DATABASES = {
    # ...
    "OPTIONS": {
        "isolation_level": IsolationLevel.SERIALIZABLE,
    },
}
1.4 Postgresql安装

在Ubuntu上安装PostgreSQL数据库可以通过几个不同的方法完成，以下是使用APT包管理器的步骤：

  1. 更新包列表

    打开终端并运行以下命令来更新Ubuntu的包列表：

    sudo apt update

  2. 安装PostgreSQL

    安装PostgreSQL及其相关的软件包：

    sudo apt install postgresql postgresql-contrib

    postgresql是PostgreSQL数据库服务器的核心包，而postgresql-contrib包含一些额外的实用程序和功能扩展。

  3. 启动和启用服务

    PostgreSQL服务通常会在安装后自动启动。您可以使用以下命令来检查其状态：

    sudo systemctl status postgresql.service

    如果服务没有运行，可以使用以下命令启动：

    sudo systemctl start postgresql.service

    要确保PostgreSQL在启动时自动启动，可以使用以下命令：

    sudo systemctl enable postgresql.service

  4. 登录到PostgreSQL

    默认情况下，PostgreSQL创建一个名为postgres的用户。在安装完成后，您可以切换到该用户，并通过以下命令启动PostgreSQL shell（称为psql）：

    sudo -i -u postgres
psql

    或者，您也可以使用以下命令直接以postgres用户身份启动psql：

    sudo -u postgres psql

  5. 创建新的角色和数据库

    如果您想创建一个新的数据库和用户（在PostgreSQL中称为“角色”），可以按照以下步骤操作：

    • 在psql提示符下创建一个新角色：

      CREATE ROLE myuser WITH LOGIN PASSWORD 'mypassword';

    • 授权角色以创建数据库：

      ALTER ROLE myuser CREATEDB;

    • 退出psql：

      \q

    • 切换回您的常规用户账户，然后以新角色身份登录：

      sudo -u myuser psql

    • 创建一个新数据库：

      CREATE DATABASE mydatabase;

    • 如果需要，您也可以为新数据库指定所有者：

      CREATE DATABASE mydatabase WITH OWNER myuser;

  6. 配置远程访问（可选）

    如果您希望允许远程访问PostgreSQL服务器，您需要编辑两个配置文件：postgresql.conf和pg_hba.conf。

    • 打开postgresql.conf文件，通常位于/etc/postgresql/<version>/main/目录中：

      sudo nano /etc/postgresql/<version>/main/postgresql.conf

      找到listen_addresses行，并将其更改为：

      listen_addresses = '*'

    • 接下来，编辑pg_hba.conf文件以配置客户端认证：

      sudo nano /etc/postgresql/<version>/main/pg_hba.conf

      在文件底部添加一行以允许远程连接：

      host all all 0.0.0.0/0 md5

    • 重启PostgreSQL服务以应用更改：

      sudo systemctl restart postgresql

    请记住，开放远程访问可能会带来安全风险，确保您的防火墙和其他安全措施配置正确，以允许可信的主机或网络访问。

完成上述步骤后，PostgreSQL应该已经成功安装并可用于Ubuntu系统。

1.5 WSL2虚拟环境Postgresql服务

WSL2 (Windows Subsystem for Linux version 2) 中的服务管理略有不同，因为它并不是一个完整的系统，而是运行在Windows之上的一个轻量级虚拟环境。

以下是在WSL2的Ubuntu环境中启动PostgreSQL作为后台服务的步骤：

  1. 启动PostgreSQL服务：

    默认情况下，安装PostgreSQL后，服务将自动启动。你可以使用以下命令检查服务状态：

    sudo service postgresql status

    如果服务没有运行，可以使用以下命令启动：

    sudo service postgresql start

    在WSL2中，你可能需要在每次启动WSL2时手动启动服务，因为它不支持Linux的systemd服务管理系统。

  2. 配置PostgreSQL以在启动时自动运行：

    虽然WSL2不支持systemd，但你可以通过在.bashrc或.zshrc文件中添加一些脚本来模拟这种行为。打开你的shell配置文件：

    nano ~/.bashrc

    在文件底部添加以下行：

    # Start PostgreSQL if it's not running
if ! pgrep -u postgres -fa -- /usr/lib/postgresql/*/bin/postgres >/dev/null; then
    sudo service postgresql start
fi

    然后保存并关闭文件。这段脚本会在你打开新的shell时检查PostgreSQL服务是否运行，如果没有运行，它会尝试启动服务。

  3. 重新加载你的bash配置或打开一个新的终端窗口：

    你可以通过运行以下命令来重新加载.bashrc文件：

    source ~/.bashrc

    或者简单地关闭并重新打开你的WSL2终端窗口。

1.6 数据库连接方式

HOST，默认为 '' （空字符串）。

连接到数据库时使用的主机。空字符串表示本地主机。不用于 SQLite。

如果这个值以斜线（'/'）开头，并且你正在使用 MySQL，MySQL 将通过 Unix 套接字连接到指定的套接字。例如：

"HOST": "/var/run/mysql"

如果你使用的是 MySQL，并且这个值 没有 以斜线开头，那么这个值被认为是主机。

如果你使用的是 PostgreSQL，默认情况下，与数据库的连接是通过 UNIX 域套接字（pg_hba.conf 中的 ‘local’ ）完成的。

如果你的 UNIX 域套接字不在标准位置，请使用 postgresql.conf 中的 unix_socket_directory 的相同值。如果你想通过 TCP 套接字连接，将HOST设置为 localhost 或 127.0.0.1（pg_hba.conf 中的 ‘host’ 行）。

在 Windows 上，你应该总是定义 HOST，因为 UNIX 域套接字是不可用的。

3.数据库模型
3.1 启动默认APP的数据模型

编辑 mysite/settings.py 文件前，先设置TIME_ZONE为你自己时区。

一般而言，Django默认情况下会携带一些APP，可以给常规项目提供帮助:

#mysite/setting.py
# Application definition
INSTALLED_APPS = [
    'django.contrib.admin', 		# 管理员站点
    'django.contrib.auth',			# 认证授权系统
    'django.contrib.contenttypes',	# 内容类型框架
    'django.contrib.sessions',		# 会话框架
    'django.contrib.messages',		# 消息框架
    'django.contrib.staticfiles',	# 管理静态文件的框架
]

默认开启的某些应用需要至少一个数据表，所以，在使用他们之前需要在数据库中创建一些表。请执行以下命令：

# 在project根目录下运行该命令
(venv) onceday->source:# python manage.py migrate -v 1
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying admin.0002_logentry_remove_auto_add... OK
  Applying admin.0003_logentry_add_action_flag_choices... OK
  Applying contenttypes.0002_remove_content_type_name... OK
  Applying auth.0002_alter_permission_name_max_length... OK
  Applying auth.0003_alter_user_email_max_length... OK
  Applying auth.0004_alter_user_username_opts... OK
  Applying auth.0005_alter_user_last_login_null... OK
  Applying auth.0006_require_contenttypes_0002... OK
  Applying auth.0007_alter_validators_add_error_messages... OK
  Applying auth.0008_alter_user_username_max_length... OK
  Applying auth.0009_alter_user_last_name_max_length... OK
  Applying auth.0010_alter_group_name_max_length... OK
  Applying auth.0011_update_proxy_permissions... OK
  Applying auth.0012_alter_user_first_name_max_length... OK
  Applying sessions.0001_initial... OK

在Postgresql数据库后端，可以看到Django默认创建了以下表格:

forwhat_main=> \dt
                   List of relations
 Schema |            Name            | Type  |  Owner
--------+----------------------------+-------+---------
 public | auth_group                 | table | forwhat
 public | auth_group_permissions     | table | forwhat
 public | auth_permission            | table | forwhat
 public | auth_user                  | table | forwhat
 public | auth_user_groups           | table | forwhat
 public | auth_user_user_permissions | table | forwhat
 public | django_admin_log           | table | forwhat
 public | django_content_type        | table | forwhat
 public | django_migrations          | table | forwhat
 public | django_session             | table | forwhat
(10 rows)
3.2 创建自己的数据模型

模型代码具体编写可参考：

Django通过自定义Python类的形式来定义具体的模型，每个模型的物理存在方式就是一个Python的类Class，每个模型代表数据库中的一张表，每个类的实例代表数据表中的一行数据，类中的每个变量代表数据表中的一列字段。

Django通过模型，将Python代码和数据库操作结合起来，实现对SQL查询语言的封装。可以不会SQL语言，同样能通过Python的代码进行数据库的操作，这就是所谓的ORM。

下面创建账户和个人权限两个模型：

#login/models.py
from django.db import models

# 用户账号信息, 用于登录, 包括用户名, 密码, 注册时间
class UserAccount(models.Model):
    uuid = models.UUIDField(primary_key=True, editable=False)
    name = models.CharField("User Name", max_length=64)
    password =models.CharField("User Password", max_length=128)#密码长度最大60
    date = models.DateTimeField("Register Date")

# 权限信息, 用于控制用户权限, 包括用户账号, 权限等级
class UserPrivilege(models.Model):
    account = models.ForeignKey(UserAccount, on_delete=models.CASCADE)
    policy = models.IntegerField("Privilege Policy")

可以在每个Field中使用一个可选的第一位置参数用于提供一个人类可读的字段名，让你的模型更友好，更易读，并且将被作为文档的一部分来增强代码的可读性。比如例子中的birthday 定义了对人类友好的名字。

这里使用ForeignKey定义了一个外键关系。每一个UserPrivilege关联到一个对应的UserAccount（注意要将外键写在‘多数’的一方）。Django支持通用的数据关系：一对一，多对一和多对多。

3.3 激活自己的数据模型

上面的一小段用于创建模型的代码给了 Django 很多信息，通过这些信息，Django 可以：

  • 为这个应用创建数据库 schema（生成 CREATE TABLE 语句）。
  • 创建可以与 Question 和 Choice 对象进行交互的 Python 数据库 API。

首先需要注册TSLogin这个APP(使用python3 manage.py startapp TSLogin创建):

#mysite/setting.py
# Application definition
INSTALLED_APPS = [
    'login',#这是一种简写，大多数情况下够用，实际上指到login/apps.py里的LoginConfig
    'django.contrib.admin', 		# 管理员站点
    'django.contrib.auth',			# 认证授权系统
    'django.contrib.contenttypes',	# 内容类型框架
    'django.contrib.sessions',		# 会话框架
    'django.contrib.messages',		# 消息框架
    'django.contrib.staticfiles',	# 管理静态文件的框架
]

注册之后，需要记录对模型文件的更改，运行以下命令：

(venv) onceday->source:# python manage.py makemigrations TSLogin
Migrations for 'TSLogin':
  TSLogin/migrations/0001_initial.py
    - Create model UserAccount
    - Create model UserPrivilege

通过运行makemigrations命令，Django 会检测对模型文件的修改，并且把这些改动保存为一个“迁移(migration)”。

migrations是Django保存模型修改记录的文件，这些文件保存在磁盘上。在例子中，它就是polls/migrations/0001_initial.py。可以打开它看看，里面保存的都是人类可读并且可编辑的内容，方便随时手动修改。

可以使用sqimigrate命令展示SQL语句，

(venv) onceday->source:# python manage.py sqlmigrate TSLogin 0001
BEGIN;
--
-- Create model UserAccount
--
CREATE TABLE "TSLogin_useraccount" (
	"uuid" uuid NOT NULL PRIMARY KEY, 
	"name" varchar(64) NOT NULL, 
	"password" varchar(128) NOT NULL, 
	"date" timestamp with time zone NOT NULL
);
--
-- Create model UserPrivilege
--
CREATE TABLE "TSLogin_userprivilege" (
	"id" bigint NOT NULL PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,
	"policy" integer NOT NULL,
    "account_id" uuid NOT NULL
);
ALTER TABLE "TSLogin_userprivilege" 
	ADD CONSTRAINT "TSLogin_userprivileg_account_id_e74ec847_fk_TSLogin_u" 
		FOREIGN KEY ("account_id")
		REFERENCES "TSLogin_useraccount" ("uuid") 
		DEFERRABLE INITIALLY DEFERRED;
CREATE INDEX "TSLogin_userprivilege_account_id_e74ec847" ON "TSLogin_userprivilege" ("account_id");
COMMIT;

(1) 注意这些指令的输出和使用的数据库有关！

(2) 数据库的表名是由应用名和模型名的小写形式连接而来，如果需要，可以自定义此行为。

(3) 主键(IDs)会被自动创建，也可以自定义。

(4) 默认的，Django 会在外键字段名后追加字符串 "_id" ，这也可以自定义。

(5) 外键关系由 FOREIGN KEY 生成。你不用关心 DEFERRABLE 部分，它只是告诉 PostgreSQL，请在事务全都执行完之后再创建外键关系。

(6) 它是为你正在使用的数据库定制的，因此特定于数据库的字段类型，字段名称的引用也是如此，例如，使用双引号或单引号。

“auto_increment”（MySQL）
“bigint PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY”（PostgreSQL）
“integer primary key autoincrement” `` (SQLite)

(7) 这个sqlmigrate 命令并没有真正在数据库中的执行迁移，相反，它只是把命令输出到屏幕上，看看 Django 认为需要执行哪些 SQL 语句。这在你想看看 Django 到底准备做什么，或者当你是数据库管理员，需要写脚本来批量处理数据库时会很有用。

也可以运行check命令，它将检查项目中的错误，并不实际进行迁移或者链接数据库的操作。

(venv) onceday->source:# python manage.py check
System check identified no issues (0 silenced).

接下来实际迁移，

(venv) onceday->source:# python manage.py migrate
Operations to perform:
  Apply all migrations: TSLogin, admin, auth, contenttypes, sessions
Running migrations:
  Applying TSLogin.0001_initial... OK

migrate命令对所有还未实施的迁移记录进行操作，本质上就是将你对模型的修改体现到数据库中具体的表中。Django通过一张叫做 django_migrations 的表，记录并跟踪已经实施的migrate动作，通过对比获得哪些迁移尚未提交。

记住修改模型时的操作分五步：

  1. 在models.py中修改模型；
  2. 运行python manage.py makemigrations为改动创建迁移记录文件；
  3. 运行python manage.py sqlmigrate TSLogin 0001，查看需要执行的SQL操作。
  4. 运行python manage.py check，检查是否存在错误。
  5. 运行python manage.py migrate，将操作同步到数据库(真正执行迁移操作)。

这些步骤在版本控制中比较有效！

4.尝试ORM(数据库API)

Django模型层自带ORM系统，会自动为每个模型创建数据库访问的API，直接拿来用就可以，非常简单、方便、易学。

首先创建一个用户信息和账号的模型，并且按照第3.3节中介绍的方法完成数据库变更，如下:

#login/models.py
from django.db import models

# Create your models here.

class user_information(models.Model):
    user_name = models.CharField(max_length=20)
    user_birthday = models.DateTimeField("birthday")
    user_money = models.IntegerField(default=1000)#默认1000积分

    def __str__(self) -> str:
        return  self.user_name+':'+str(self.user_money)
    def add_money(self,money):#加钱
        self.user_money+=money
        return self.user_money

class account(models.Model):
    user = models.ForeignKey(user_information,on_delete=models.CASCADE)
    account_name = models.CharField(max_length=30)#账户名最大字符长度30
    password =models.CharField(max_length=60)#密码长度最大60

    def __str__(self) -> str:
        return  self.account_name

下面，让我们进入Python交互环境，尝试使用Django提供的数据库访问API。

相比较直接输入“python”命令的方式进入Python环境，调用manage.py参数能将DJANGO_SETTINGS_MODULE环境变量导入，它将自动按照mysite/settings.py中的设置，配置好你的python shell环境，这样，你就可以导入和调用任何你项目内的模块了。

(venv) onceday->source:# python manage.py shell
Python 3.11.4 (main, Dec  7 2023, 15:43:41) [GCC 12.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)

然后进行一些基本操作，注意脚本命令和写代码是一样的使用方式：

>>> from login.models import user_information,account # 导入我们写的模型类
#查询所有的用户信息
>>> user_information.objects.all()
<QuerySet []>

>>> from django.utils import timezone
#获取时间
>>> timezone.now()
datetime.datetime(2022, 2, 13, 4, 20, 57, 797311, tzinfo=datetime.timezone.utc)
#转化为本地时间
>>> timezone.localtime(timezone.now())
datetime.datetime(2022, 2, 13, 12, 23, 28, 577106, tzinfo=zoneinfo.ZoneInfo(key='Asia/Shanghai'))
#创建一个用户对象
>>> u1= user_information(user_name="once day",user_birthday=timezone.now(),user_money=100000)
#显示保存到数据库
>>> u1.save()
 # 默认情况，你会自动获得一个自增的名为id的主键
>>> u1.id
1
# 通过python的属性调用方式，访问模型字段的值
>>> u1.user_name
'once day'
>>> u1.user_money
100000
# 通过修改属性来修改字段的值，然后显式的调用save方法进行保存。
>>> u1.user_money=99999
>>> u1.user_money
99999
>>> u1.save()
#查询对象
>>> u1
<user_information: user_information object (1)>

上面的<Question: Question object>是一个不可读的内容展示，你无法从中获得任何直观的信息，为此我们需要一点小技巧，让Django在打印对象时显示一些我们指定的信息。

#login/models.py
from django.db import models

# Create your models here.

class user_information(models.Model):
    user_name = models.CharField(max_length=20)
    user_birthday = models.DateTimeField("birthday")
    user_money = models.IntegerField(default=1000)#默认1000积分

    def __str__(self) -> str:
        return  self.user_name+':'+str(self.user_money)
    def add_money(self,money):#加钱
        self.user_money+=money
        return self.user_money

class account(models.Model):
    user = models.ForeignKey(user_information,on_delete=models.CASCADE)
    account_name = models.CharField(max_length=30)#账户名最大字符长度30
    password =models.CharField(max_length=60)#密码长度最大60

    def __str__(self) -> str:
        return  self.account_name

上面重载了一个内部函数__str__，可告诉python解释器打印什么内容。并且新增一个加钱函数。

重启命令行！然后进行下列操作

>>> from login.models import user_information,account # 导入我们写的模型类
#获取之前创建的对象
>>> u1=user_information.objects.get(id=1)
#这下可以打印关键信息
>>> u1
<user_information: once day:99999>
#查询所有的对象
>>> user_information.objects.all()
<QuerySet [<user_information: once day:99999>]>
# Django提供了大量的关键字参数查询API
>>> user_information.objects.filter(id=1)
<QuerySet [<user_information: once day:99999>]>
>>> user_information.objects.filter(user_name="once day")
<QuerySet [<user_information: once day:99999>]>
#使用自定义方法
>>> u1.add_money(1000000)
1099999
>>> u1
<user_information: once day:1099999>
# 显示所有与q对象有关系的choice集合，目前是空的，还没有任何关联对象。
>>> u1.account_set.all()
<QuerySet []>
#创建两个账户
>>> u1.account_set.create(account_name="onceday",password="1234566")
<account: onceday>
>>> u1.account_set.create(account_name="mark",password="123456")
<account: mark>
#再次查询
>>> u1.account_set.all()
<QuerySet [<account: onceday>, <account: mark>]>
#获取第二个账户对象
>>> a1=u1.account_set.get(id=2)
>>> a1.user
<user_information: once day:1099999>
#删除该对象
>>> a1.delete()
(1, {'login.account': 1})
#再次查询，删除成功
>>> u1.account_set.all()
<QuerySet [<account: onceday>]>

这只是模型的基础操作中一部分，可以尝试增强印象！

更多数据库API操作可访问官方文档: 执行查询 | Django 文档 | Django (djangoproject.com)

5.admin后台管理

Django最大的优点之一，就是体贴的为你提供了一个基于项目model创建的一个后台管理站点admin。这个界面只给站点管理员使用，并不对大众开放。

首先创建管理员用户，

(venv) onceday->source:# python manage.py createsuperuser
Username (leave blank to use '54041'): onceday
Email address: 54041551@qq.com
Password:
Password (again):
Superuser created successfully.

然后启动服务器， python manage.py runserver，浏览器输入http://127.0.0.1:8000/admin/，出现登入界面，输入用户和密码登入。

可以将管理后台的url给换掉，在urls.py配置这里修改即可！

目前站点里面只能看到django.contrib.auth模块提供的身份认证框架内的模型，Groups和Users。

FullStack之Django(2)模型和后台-LMLPHP

在admin中注册login应用后，就可以在站点中进行管理！

#login/admin.py
from django.contrib import admin

# Register your models here.

from login.models import user_information
#导入模块并注册
admin.site.register(user_information)

重新运行服务器！并且访问管理站点！

FullStack之Django(2)模型和后台-LMLPHP

这里需要注意的是：

  • 页面中的表单是由user_information模型自动生成的。
  • 不同的模型字段类型(DateTimeField, CharField)会表现为不同的HTML input框类型。
  • 每一个DateTimeField都会自动生成一个可点击链接。日期是Today，并有一个日历弹出框；时间是Now，并有一个通用的时间输入列表框。

在页面的底部，则是一些可选项按钮：

  • delete：弹出一个删除确认页面
  • save and add another：保存当前修改，并加载一个新的空白的当前类型对象的表单。
  • save and continue editing：保存当前修改，并重新加载该对象的编辑页面。
  • save：保存修改，返回当前对象类型的列表页面。

点击页面右上角的History，可以看到对当前对象的所有修改操作记录，包括修改时间和操作人员。

如果时间存在问题，是没有正确的配置TIME_ZONE，在国内，通常是8个小时的时间差别。需要在

mysite/setting.py里修改以下代码：

# Internationalization
# https://docs.djangoproject.com/en/4.0/topics/i18n/

LANGUAGE_CODE = 'en-us'
#改下面这一行
TIME_ZONE = 'Asia/Shanghai'

USE_I18N = True

USE_TZ = True
注：本文章内容收集总结于互联网，仅供学习之用！
02-02 06:41
Powered by LMLPHP ©2024 Once_day 0.009727