Kerangka web Django memiliki arsitektur model-view-template (MVT), yang menjadikannya satu-satunya kerangka kerja yang Anda perlukan untuk membuat situs web atau aplikasi web lengkap. Kerangka kerja Python ini memungkinkan Anda membuat model yang menghasilkan database dan merender template HTML dinamis ke UI menggunakan tampilan.

Kekuatan Django bukanlah rahasia; cepat, andal, terukur, dan aman. Keandalan, serta skalabilitas perangkat lunak ini, bergantung pada arsitektur MVT-nya. Dan dalam artikel ini, anda akan mempelajari dengan tepat bagaimana arsitektur MVT Django bekerja.

Apa Model Django?

Model dalam arsitektur MVT Django mendefinisikan struktur dan perilaku data yang ingin Anda simpan melalui situs web Anda. Setiap model Django yang Anda buat menghasilkan tabel database yang sesuai, di mana setiap atribut model menjadi bidang dalam tabel.

Melanjutkan pengaturan dari kami artikel pengantar tentang Django, Anda dapat membuat model untuk penjual. Penjual dapat memiliki model penjual yang memiliki informasi pribadi, seperti nama dan detail kontak, serta model terkait untuk barang yang dijual setiap penjual.

Contoh Struktur File Proyek Django yang Ada

Situsku/
 Situsku/
 _pycache_
 _init_.py
 asgi.py
 setting.py
 urls.py
 wsgi.py
 penjual/
 migrasi
 _init_.py
 admin.py
 apps.py
 model.py
 test.py
 views.py
 db.sqlite3
 kelola.py

Membuat Model Django

Jika Anda melihat di bawah bagian aplikasi penjual di struktur file di atas, Anda akan melihat file bernama model.py. Di sinilah Anda akan membuat semua model Django Anda untuk bagian penjual situs web Anda. Setiap model yang Anda buat akan menjadi subkelas dari Model API Django, itulah sebabnya setiap Django yang dihasilkan model.py file memiliki impor model default.

File model.py

Dari model impor django.db
# Buat model Anda di sini.
kelas Penjual (model. Model):
first_name = model. CharField (max_length=30)
nama_belakang = model. CharField (max_length=30)
contact_number = model. CharField (max_length=30)
Produk kelas (model. Model):
penjual = model. ForeignKey (Penjual, on_delete=models. RIAM)
item_name = model. CharField (max_length=100)
item_qantity = model. IntegerField()
item_price = model. DecimalField (max_digits=9, desimal_places=2)
item_description = model. Bidang Teks()

Kode di atas adalah salinan dari konten terbaru dari model.py mengajukan. File sekarang membuat dua model—Penjual dan Produk. Model ini berbagi hubungan satu-ke-banyak, di mana satu penjual dapat memiliki banyak produk yang dijual. Jadi, model Produk memiliki kunci asing dari penjual dan di_hapus atribut disetel ke model. RIAM, yang berarti saat Anda menghapus penjual, Anda akan otomatis menghapus setiap produk yang memilikinya kunci utama sebagai kunci asing.

Terkait: Pelajari Python dan Django Hari Ini Dengan Kursus Menakjubkan Ini Anda mungkin juga memperhatikan bahwa setiap model dalam kode di atas tidak memiliki kunci utama. Ini karena Django akan secara otomatis menghasilkan kunci utama jika Anda tidak membuatnya secara eksplisit.

Sebelum Anda dapat menggunakan model apa pun yang Anda buat, Anda harus memberi tahu Django di mana menemukannya. Untuk melakukan ini, Anda harus menavigasi ke setting.py file dan masukkan nama modul yang berisi model.py file, ke dalam INSTALLED_APP bagian.

Dalam proyek sampel untuk artikel ini, model.py file ada di modul penjual. Oleh karena itu, yang diperbarui INSTALLED_APP bagian akan berbunyi sebagai berikut:

INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'penjual',
]

Dengan kode di atas, model dalam aplikasi penjual sekarang terlihat ke situs web Django, dan sekarang Anda dapat melanjutkan ke migrasi.

Melakukan migrasi penting karena proses ini adalah cara menyebarkan perubahan yang Anda buat di model ke skema database yang sesuai. Jadi, setiap kali Anda membuat perubahan pada model Anda, Anda harus melakukan proses migrasi—yang melibatkan dua langkah.

Langkah pertama adalah melakukan migrasi, yaitu perintah yang membuat migrasi berdasarkan perubahan yang terdeteksi di model.py mengajukan. Untuk memulai proses migrasi, Anda perlu membuka terminal Anda, navigasikan ke direktori yang memiliki proyek Django Anda, dan luncurkan server menggunakan perintah berikut:

python manage.py runserver

Dengan server berjalan di satu terminal, buka terminal baru dan masukkan perintah berikut:

python manage.py makemigrations

Setelah eksekusi, terminal akan menghasilkan output berikut:

Migrasi untuk 'penjual':
seller\migrations\0001_initial.py
- Buat Model Penjual
- Buat model Produk

Output di atas dengan jelas menyatakan bahwa Anda sekarang memiliki migrasi untuk dua model—penjual dan produk. Sekarang jika Anda menavigasi ke folder migrasi di modul penjual Anda, Anda akan melihat bahwa sekarang memiliki file baru bernama 0001_initial.py. Di dalam file ini, Anda akan menemukan migrasi yang baru saja Anda buat.

File 0001_initial.py

# Dihasilkan oleh Django 3.2.9 pada 2022-02-26 16:06
dari migrasi impor Django.db, model
impor django.db.models.deletion
kelas Migrasi (migrasi. Migrasi):
awal = benar
ketergantungan = [
]
operasi = [
migrasi. BuatModel(
nama='Penjual',
bidang=[
('id', model. BigAutoField (auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('nama_depan', model. CharField (max_length=30)),
('nama_belakang', model. CharField (max_length=30)),
('nomor_kontak', model. CharField (max_length=30)),
],
),
migrasi. BuatModel(
nama='Produk',
bidang=[
('id', model. BigAutoField (auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('nama_item', model. CharField (max_length=100)),
('jumlah_item', model. IntegerField()),
('harga_barang', model. DecimalField (desimal_places=2, max_digits=9)),
('item_description', model. Bidang Teks()),
('penjual', model. ForeignKey (on_delete=django.db.models.deletion. CASCADE, to='penjual.penjual')),
],
),
]

Setiap kali Anda melakukan migrasi baru, folder migrasi menghasilkan versi baru dari file ini.

Langkah kedua dari proses migrasi adalah memigrasikan model. Ini berarti Anda menyinkronkan status database dengan model.py file, menggunakan migrasi yang baru saja Anda buat di 0001_initial.py mengajukan. Anda dapat menyelesaikan proses ini (saat server masih berjalan) dengan perintah berikut:

python manage.py migrasi

Apa Itu Template Django?

Templat adalah cara untuk menghasilkan HTML secara dinamis untuk proyek Django Anda. Setiap templat Django memiliki .html ekstensi dan kombinasi konten statis dan dinamis. Templat Django memiliki sintaks unik yang menyertakan cara baru membuat variabel dan tag dalam dokumen HTML.

Membuat Template Django

Untuk memperkenalkan template di contoh situs web E-niaga untuk artikel ini, Anda harus membuat direktori baru di modul penjual. Direktori baru yang disebut "templat" ini akan menjadi rumah bagi semua dokumen HTML untuk aplikasi penjual—dimulai dengan halaman beranda.

File seller_home.html

Selamat Datang Penjual!

Setelah Anda membuat templat Anda, Anda harus membuatnya terlihat oleh Django dengan menambahkan direktori templat Anda ke TEMPLATE bagian dari setting.py mengajukan. yang diperbarui TEMPLATE bagian akan terlihat seperti berikut:

TEMPLATE = [
{
'BACKEND': 'django.template.backends.django. DjangoTemplate',
'DIRS': [
# kode baru yang menunjuk ke lokasi template
BASE_DIR / 'penjual' / 'templat'
],
'APP_DIRS': Benar,
'PILIHAN': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]

Sekarang Django mengetahui di mana menemukan templat untuk situs web, Anda dapat melanjutkan dan merendernya ke UI menggunakan tampilan.

Apakah Pandangan Django?

View adalah lapisan kedua dari arsitektur MVT Django, sebuah template tidak berguna kecuali sebuah view merendernya ke UI. Tampilan bertanggung jawab untuk menerima permintaan web dan mengembalikan tanggapan yang sesuai (termasuk template). Dalam bentuknya yang paling dasar, tampilan adalah fungsi Python, disimpan di lihat.py file proyek Django Anda.

Membuat Tampilan Django

Itu lihat.py file ada di modul penjual dari contoh proyek Django. Saat penjual mengunjungi situs web Anda, Anda ingin mereka membuka halaman beranda penjual. Beranda ini akan Anda buat menggunakan template HTML, seperti yang dibuat di bagian template di atas.

File view.py

dari django.shortcuts impor render
indeks def (permintaan):
mengembalikan render (permintaan, 'seller_home.html')

Tampilan di atas menerima permintaan dan mengembalikan template HTML penjual. Jadi, setiap kali pengguna mengunjungi (atau meminta) http://127.0.0.1:8000/sellers/ mereka akan melihat beranda penjual. Ini setelah Anda membuat urls.py file dalam modul penjual.

File urls.py Penjual

dari jalur impor Django.urls
dari. impor tampilan
pola url = [
path('', views.index, nama='index'),
]

Dan sertakan jalur ke modul penjual urls.py file di urls.py file yang terletak di direktori utama Django.

File urls.py Situs Web

dari django.contrib impor admin
dari impor django.urls termasuk, path
pola url = [
path('penjual/', termasuk('penjual.url')),
path('admin/', admin.site.urls),
]

Sekarang setelah tampilan disetel, Anda dapat memastikan bahwa server Django masih berjalan dan menavigasi ke http://127.0.0.1:8000/sellers/ di browser Anda untuk melihat beranda penjual.

Halaman Beranda Penjual

Arsitektur MVT Django vs. Arsitektur MVC

Arsitektur MVT Django cukup berbeda dari arsitektur MVC populer.

Bagian template arsitektur MVT beroperasi dengan cara yang sama seperti tampilan dalam arsitektur MVC, sedangkan tampilan dalam arsitektur MVT menampilkan kualitas yang mirip dengan pengontrol di MVC Arsitektur. Namun, model di kedua arsitektur bekerja secara identik.

Pengantar Arsitektur MVC: Contoh Dijelaskan

Terapkan prinsip desain Model-View-Controller ke program Anda sendiri untuk hasil langsung. Berikut adalah cara untuk memulai.

Baca Selanjutnya

Tentang Penulis