Sistem blog berbilang pengguna yang dilaksanakan oleh Django

Django ialah rangka kerja web yang cekap berdasarkan bahasa pengaturcaraan Python Ia menyediakan rangka kerja corak MVC lengkap yang boleh melaksanakan aplikasi web dengan mudah. Dalam artikel ini, saya akan memperkenalkan cara menggunakan Django untuk melaksanakan sistem blog berbilang pengguna supaya berbilang pengguna boleh mendaftar, log masuk dan menerbitkan catatan blog mereka sendiri.

Langkah pertama ialah memasang Django
Sebelum memulakan pembangunan, anda perlu memasang Django. Anda boleh menggunakan arahan berikut untuk memasang versi terkini Django:

pip install Django

Langkah kedua ialah mencipta projek dan aplikasi Django
Dalam Django, projek boleh mengandungi berbilang aplikasi. Aplikasi biasanya bertanggungjawab untuk fungsi tertentu. Sekarang, kita perlu mencipta projek Django dan aplikasi blog. Ia boleh dibuat menggunakan arahan berikut:

django-admin startproject myblog
cd myblog
python manage.py startapp blog

Dalam arahan di atas, kami mencipta projek yang dipanggil Projek Django Myblog, dan mencipta aplikasi bernama blog dalam projek itu.

Langkah ketiga ialah mengkonfigurasi pangkalan data
Dalam Django, pangkalan data lalai ialah SQLite, tetapi pangkalan data lain (seperti MySQL, PostgreSQL, dll.) juga boleh digunakan. Kita perlu mengkonfigurasinya dalam fail settings.py projek Django. Buka fail settings.py dan tambah maklumat konfigurasi pangkalan data yang sesuai dalam DATABASES.

Langkah 4, tentukan model
Sekarang, kita perlu menentukan model catatan blog. Dalam Django, model mentakrifkan jadual pangkalan data dan medan yang dikaitkan dengan jadual itu. Dalam fail models.py aplikasi blog, kita boleh mentakrifkan model berikut:

daripada model import django.db
daripada django.contrib.auth.models import User

kelas Siaran (model.Model):

title = models.CharField(max_length=100)
content = models.TextField()
pub_date = models.DateTimeField(auto_now_add=True)
author = models.ForeignKey(User, on_delete=models.CASCADE)

Dalam model, kami mentakrifkan model Siaran, yang mengandungi medan berikut:

tajuk: Tajuk artikel, taip CharField.
kandungan: kandungan artikel, jenis ialah TextField.
pub_date: masa penerbitan artikel, jenis ialah DateTimeField, medan ini menggunakan parameter auto_now_add=True, yang bermaksud ia ditetapkan secara automatik kepada masa semasa semasa membuat artikel baharu.
pengarang: pengarang artikel, taip ForeignKey, dikaitkan dengan model Pengguna terbina dalam Django.

Langkah 5, konfigurasikan penghalaan
Kini kami perlu mengkonfigurasi penghalaan URL supaya aplikasi kami boleh mengendalikan permintaan yang berbeza (seperti senarai catatan blog, butiran siaran, buat siaran, dll.). Dalam fail urls.py aplikasi, kami boleh menambah kod berikut:

dari laluan import django.urls
daripada paparan import

urlpatterns = [

path('', views.IndexView.as_view(), name='index'),
path('post/<int:pk>/', views.PostDetailView.as_view(), name='post_detail'),
path('post/add/', views.PostCreateView.as_view(), name='post_create'),

<.>]

Dalam kod di atas, kami mentakrifkan tiga laluan:

Laluan kosong menghala ke fungsi paparan IndexView.as_view() dan dinamakan "index".

Laluan yang digunakan untuk memaparkan butiran artikel. Laluan menerima parameter integer bernama pk dan menunjuk ke fungsi paparan PostDetailView.as_view() bernama "post_detail".
Laluan untuk mencipta artikel baharu. Laluan ini menghala ke fungsi paparan PostCreateView.as_view() dan dinamakan "post_create".

Langkah 6, tentukan paparan

Sekarang kita perlu menentukan fungsi paparan yang mengendalikan penghalaan untuk bertindak balas kepada permintaan yang berbeza. Fungsi ini harus mengembalikan objek HttpResponse yang mengandungi kandungan HTML, JSON atau XML respons yang diingini. Dalam fail views.py aplikasi blog, kita boleh mentakrifkan fungsi paparan berikut:

daripada django.contrib.auth.mixins import LoginRequiredMixin

dari django.views.generic import ListView, DetailView, CreateView
daripada .models import Post

class IndexView(ListView):

model = Post
template_name = 'blog/index.html'
context_object_name = 'posts'
ordering = ['-pub_date']

class PostDetailView(DetailView):

model = Post
template_name = 'blog/post_detail.html'
context_object_name = 'post'

class PostCreateView(LoginRequiredMixin, CreateView):

model = Post
template_name = 'blog/post_form.html'
fields = ['title', 'content']
success_url = '/'

def form_valid(self, form):
    form.instance.author = self.request.user
    return super().form_valid(form)

Dalam kod di atas, kami mentakrifkan tiga fungsi paparan:

IndexView: Memaparkan senarai catatan blog. Paparan ini mewarisi daripada ListView dan boleh dilaksanakan dengan menentukan atribut seperti model, nama_templat, nama_objek_konteks dan pesanan.

PostDetailView: Memaparkan butiran satu catatan blog. Diwarisi daripada DetailView, hanya perlu menentukan model dan template_name.
PostCreateView: digunakan untuk membuat catatan blog baharu. Diwarisi daripada CreateView, anda perlu menentukan atribut seperti model, template_name, medan dan success_url. Pada masa yang sama, kami menggunakan kelas mixin LoginRequiredMixin untuk memastikan bahawa hanya pengguna log masuk boleh mengakses paparan. Dalam kaedah form_valid(), kami menetapkan pengarang artikel kepada pengguna semasa.

Langkah 7, tulis templat

Akhir sekali, kita perlu menulis templat yang sepadan dengan fungsi paparan. Dalam direktori templat aplikasi blog, kita boleh mencipta fail templat berikut:

base.html: templat asas yang digunakan untuk semua halaman.

index.html: Templat yang memaparkan semua catatan blog.
post_detail.html: Templat yang memaparkan butiran satu catatan blog.
post_form.html: Templat untuk membuat catatan blog baharu.

Antaranya, base.html mengandungi elemen halaman yang biasa kepada templat lain. index.html memaparkan ringkasan semua catatan blog dan menyediakan pandangan yang dipautkan kepada butiran siaran. post_detail.html memaparkan butiran satu catatan blog sambil menyediakan pautan kepada paparan untuk mengedit dan memadamkan siaran. post_form.html Borang untuk membuat catatan blog baharu.

Melalui langkah di atas, kita boleh menggunakan Django untuk melaksanakan sistem blog berbilang pengguna. Sistem ini membenarkan berbilang pengguna untuk mendaftar, log masuk dan menerbitkan catatan blog mereka sendiri. Ini menjadikan kandungan laman web lebih kaya, dan juga memudahkan komunikasi dengan pengguna lain dan menghargai artikel.

Atas ialah kandungan terperinci Sistem blog berbilang pengguna yang dilaksanakan oleh Django. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!