คู่มือสร้างแอปย่อ URL ด้วย Django
เผยแพร่แล้ว: 2021-05-09วิธีที่ดีที่สุดในการเรียนรู้ Django หรือทักษะใดๆ คือการใช้ความรู้ที่คุณมีโดยการสร้างโครงการที่ใช้งานได้จริง
Django เป็นเฟรมเวิร์กการพัฒนาเว็บ Python ที่ใช้มากที่สุด คุณสมบัติในตัวและแพ็คเกจของบุคคลที่สามจำนวนมากทำให้เป็นหนึ่งในเฟรมเวิร์กเว็บที่เป็นที่ชื่นชอบมากที่สุดทั่วโลก
มีความรวดเร็ว เชื่อถือได้ และมีคุณสมบัติในตัวมากมาย ตัวอย่างเช่น ระบบตรวจสอบช่องโหว่ที่ให้คุณมุ่งเน้นไปที่คุณสมบัติหลักของแอพของคุณ นอกจากนี้ คุณยังสามารถติดตั้งแพ็คเกจภายนอกเพื่อทำงานที่ซับซ้อนยิ่งขึ้น เช่น Django-allauth ซึ่งช่วยให้คุณลงทะเบียนผู้ใช้ด้วยบัญชีโซเชียลของพวกเขาได้
แต่ขอเปิดเผยข้อเท็จจริงบางอย่าง Django เป็นเฟรมเวิร์กที่ใหญ่มาก ซึ่งบางครั้งก็ท้าทายในการเริ่มต้นใช้งาน
ดังนั้นวันนี้คุณกำลังจะสร้างแอปพลิเคชัน Django ที่ใช้งานได้จริงทั้งหมดตั้งแต่ต้น
ในตอนท้ายของบทช่วยสอนนี้ คุณจะ:
- ได้เขียนแอพย่อ URL
- ทำความเข้าใจกับรูปแบบ Django MVT
- ได้เรียนรู้เวิร์กโฟลว์การสร้างโปรเจ็กต์
ข้อกำหนดเบื้องต้น
ข้อกำหนดทั้งหมดต่อไปนี้เป็นทางเลือก และจะช่วยให้คุณปฏิบัติตามบทช่วยสอนได้ แต่ถ้าคุณไม่มีประสบการณ์กับสิ่งเหล่านี้ก็ไม่ต้องกังวล ขั้นตอนที่สำคัญที่สุดคือขั้นตอนแรก
- ความเข้าใจพื้นฐานของคำสั่ง UNIX (ls, cd, rm, touch)
- ความเข้าใจพื้นฐานเกี่ยวกับคลาสและฟังก์ชันของ Python
- Python ติดตั้งบนคอมพิวเตอร์ของคุณ (อาจจะชัดเจน แต่ฉันต้องรวมไว้)
- คงจะดีไม่น้อยถ้าคุณได้สร้างอะไรบางอย่างกับ Django
รหัสการทำงานทั้งหมดจะมีอยู่ใน repo Github นี้
ตอนนี้คุณมีแนวคิดที่ชัดเจนเกี่ยวกับแนวคิดก่อนหน้านี้แล้ว มาเข้าเรื่องกัน
แถลงการณ์โครงการ
ในบทช่วยสอนนี้ คุณจะต้องสร้างตัวย่อ URL โดยพื้นฐานแล้ว ตัวย่อ URL เป็นบริการที่ใช้ URL ที่ยาวและเปลี่ยนให้เป็น URL แบบย่อ
ตัวอย่างเช่น หากคุณต้องการแชร์ทวีตและต้องการใส่ลิงก์ไปยังเว็บไซต์ของคุณ แต่คุณกำลังเผชิญกับการจำกัดจำนวนอักขระ คุณสามารถใช้ตัวย่อ URL ได้
มาดูด้วยกราฟิคกัน
อย่างที่คุณเห็น URL shortener ได้รับ URL แบบยาวและส่งคืน URL แบบสั้น นั่นคือสิ่งที่คุณกำลังจะสร้างในวันนี้
ด้วยโปรเจ็กต์นี้ คุณจะได้ฝึกฝนการใช้รูปแบบ MVT เรียนรู้พื้นฐานของการออกแบบฐานข้อมูลด้วยโมเดล Django และเรียนรู้วิธีแสดงข้อมูลต่อผู้ใช้ผ่านมุมมอง URL และเทมเพลต
โครงสร้างของโครงการจังโก้
โดยทั่วไป เว็บไซต์ Django สร้างขึ้นจาก โปรเจ็กต์ เดียวและ แอป แยกหลาย แอป แอปเหล่านี้แต่ละแอปมีฟังก์ชันการทำงานเฉพาะและสามารถทำงานได้ด้วยตัวเอง
ลองนึกภาพเว็บแอปพลิเคชันที่ซับซ้อน เช่น Stackoverflow การทำงานของมันขึ้นอยู่กับสองประเด็นหลัก
- การจัดการผู้ใช้: ลงชื่อเข้าใช้, ออกจากระบบ, ชื่อเสียง, สิทธิ์
- ฟอรัม: คำถาม คำตอบ แท็ก ตัวกรอง
ดังนั้นตามโครงสร้างเว็บไซต์ Django โปรเจ็กต์จึงมีชื่อว่า StackOverflow ซึ่งมีแอปหลักสองแอป แอพ ของผู้ใช้ และแอพ ฟอรั่ม
แอปเหล่านี้แต่ละแอปมีฟังก์ชันการทำงานในตัวเอง นั่นหมายความว่าทั้งคู่มีรหัสทั้งหมดที่จำเป็นในการทำงานอย่างถูกต้อง
ซึ่งรวมถึงโมเดล (โครงสร้างฐานข้อมูล) มุมมอง (คำขอและการตอบสนอง) รูปแบบ URL ที่เฉพาะเจาะจง และแน่นอน เทมเพลตและไฟล์คงที่ (รูปภาพ, CSS, JavaScript) ซึ่งหมายความว่าแอพ Django ใด ๆ ที่สามารถนำมาใช้ซ้ำได้เนื่องจากสามารถทำงานได้ด้วยตัวเอง
ย่อ โปรเจ็กต์หมายถึงชุดของการกำหนดค่าและแอพที่มีไว้สำหรับสร้างเว็บแอปพลิเคชัน ในทางกลับกัน แอพ Django เป็นส่วนหนึ่งของโปรเจ็กต์ซึ่งมีอยู่ในตัวเอง (มีทุกสิ่งที่จำเป็นในการทำงาน) และจุดประสงค์ของมันคือการดำเนินการเฉพาะ
ตั้งโปรเจ็กต์จังโก้
ในส่วนนี้ คุณจะตั้งค่าโปรเจ็กต์ Django เพื่อจุดประสงค์นั้น คุณจะใช้เครื่องมือต่างๆ เช่น Virtual Environment เพื่อจัดระเบียบการพึ่งพา Python และสคริปต์ Django ที่สำคัญที่สุด Django-admin และ Manage.py
สภาพแวดล้อมเสมือนจริง
ฉันแนะนำให้ทำงานกับสภาพแวดล้อมเสมือนเสมอเมื่อสร้างแอปด้วย Django เป็นวิธีที่มีประสิทธิภาพมากที่สุดในการรักษาชุดการพึ่งพาเฉพาะ แต่จุดประสงค์หลักของมันคือการแยกแพ็คเกจการพัฒนาออกจากแพ็คเกจระดับโลก
มาสร้างสภาพแวดล้อมเสมือนด้วยคำสั่ง python form ในตัวกัน
หมายเหตุ: วิธีนี้ต้องใช้ Python 3.6 หรือเวอร์ชันที่ใหม่กว่าจึงจะใช้งานได้
python -m venv .venvคำสั่งนี้ใช้คำสั่ง python -m หรือ python –mod โดยพื้นฐานแล้วจะเรียกใช้โมดูลหรือไลบรารีเป็นสคริปต์ ตามความหมายของคำสั่งนี้ venv คือไลบรารีที่เรากำลังเรียกใช้ และ . venv หมายถึงชื่อของสภาพแวดล้อมเสมือนที่เราต้องการสร้าง
ดังนั้นในภาษาธรรมดา คำสั่งนี้จึงหมายถึง
สวัสดี Python เรียกใช้เป็นสคริปต์ venv ไลบรารีใน ตัว และสร้างชื่อ virtualenv .venv
ถึงเวลาเปิดใช้งานสภาพแวดล้อมเสมือนที่เราเพิ่งสร้างขึ้นด้วยคำสั่งต่อไปนี้
source .venv/bin/activateเพื่อยืนยันว่าคุณไม่มีแพ็คเกจที่ติดตั้งใน venv ใหม่ คุณเรียกใช้
pip freezeหากคุณเปิดใช้งานสภาพแวดล้อมเสมือนอย่างถูกต้อง คุณจะไม่ได้รับผลลัพธ์ใดๆ นั่นเป็นเพราะเรายังไม่ได้ติดตั้งอะไรเลย
เข้าจังโก้กันเถอะ
ในการสร้างแอปพลิเคชันตัวย่อ URL เราจะเริ่มต้นด้วยการติดตั้งแพ็คเกจ Django Django เป็นแพ็คเกจของบุคคลที่สาม ดังนั้นเราต้องติดตั้งด้วย Pip (Pip Installs Packages)
$ pip install django Collecting django Downloading Django-3.2.1-py3-none-any.whl (7.9 MB) |████████████████████████████████| 7.9 MB 344 kB/s Collecting asgiref<4,>=3.3.2 Using cached asgiref-3.3.4-py3-none-any.whl (22 kB) Collecting sqlparse>=0.2.2 Using cached sqlparse-0.4.1-py3-none-any.whl (42 kB) Collecting pytz Using cached pytz-2021.1-py2.py3-none-any.whl (510 kB) Installing collected packages: asgiref, sqlparse, pytz, django Successfully installed asgiref-3.3.4 django-3.2.1 pytz-2021.1 sqlparse-0.4.1หมายเหตุ: จำไว้ว่า $ ไม่ใช่อะไรนอกจากสัญลักษณ์เชลล์ของคุณ
เพื่อตรวจสอบว่าการติดตั้งดำเนินไปอย่างถูกต้องหรือไม่ เราตรวจสอบแพ็คเกจที่ติดตั้งของ venv ของเราอีกครั้ง
$ pip freeze asgiref==3.3.4 Django==3.2.1 pytz==2021.1 sqlparse==0.4.1ไม่ต้องกังวลหากเวอร์ชันที่คุณได้รับจะแตกต่างจากของฉัน หาก Django ยังคงอยู่ในเวอร์ชัน 3.x คุณสามารถดำเนินการต่อได้โดยไม่มีปัญหาใดๆ
เริ่มโปรเจกต์จังโก้
เมื่อคุณติดตั้ง Django แล้ว ก็ถึงเวลาสร้างโครงสร้างของเว็บไซต์ตัวย่อ URL คุณจำโครงการ Django ได้หรือไม่? มาสร้างกันโดยใช้คำสั่งต่อไปนี้
django-admin startproject config อธิบายทั้งหมดเกี่ยวกับคำสั่งนี้ django-admin เป็นยูทิลิตี้บรรทัดคำสั่งที่ทำงานที่จำเป็นทั้งหมดเพื่อสร้างโครงการ Django ส่วน "startproject" คือคำสั่งที่รันโดยยูทิลิตี้ Django-admin และ config คือชื่อของโปรเจ็กต์ที่เราจะสร้าง
สิ่งสำคัญคือต้องเน้นว่า config สามารถเป็นชื่อใดก็ได้ที่คุณต้องการ เหตุผลที่ฉันใช้ config เป็นชื่อโปรเจ็กต์นี้เป็นเพราะความสะดวก เป็นการดีที่จะสลับไปมาระหว่างโปรเจ็กต์และยังคงใช้หลักการตั้งชื่อแบบเดิม ดังนั้นอย่ากลัวที่จะใช้ชื่อโครงการอื่นเมื่อใดก็ได้ที่คุณต้องการ
อย่างที่คุณอาจสังเกตเห็นว่าตอนนี้คุณมี config/ โฟลเดอร์และข้างในมีไฟล์มากมาย ต่อมาเราจะเห็นโครงสร้างไฟล์ของโครงการ ในตอนนี้ ให้เข้าสู่ไดเร็กทอรีโครงการและเรียกใช้เซิร์ฟเวอร์ภายในเครื่อง
cd config/ไฟล์ที่สำคัญที่สุดที่คุณจะใช้คือสคริปต์ Manage.py มีฟังก์ชันการทำงานเหมือนกับ django-admin แต่ประโยชน์หลักของการใช้งานคือช่วยให้คุณจัดการการตั้งค่าเมื่อเรียกใช้โครงการ
ตอนนี้เรามาดูกันว่าทุกอย่างทำงานอย่างถูกต้องหรือไม่
python manage.py runserver 
การสร้างแอปตัวย่อ URL
ได้เวลาสร้างแอปหลักของโครงการแล้ว คุณจะใช้ไฟล์ Manage.py เพื่อทำงานนี้ให้สำเร็จ
python manage.py startapp urlshortenerสิ่งนี้จะสร้างแอป Django ด้วยชื่อ urlshortener หากคุณรันคำสั่ง tree คุณจะได้สิ่งนี้
. ├── config │ ├── asgi.py │ ├── __init__.py │ ├── settings.py │ ├── urls.py │ └── wsgi.py ├── manage.py └── urlshortener ├── admin.py ├── apps.py ├── __init__.py ├── migrations │ └── __init__.py ├── models.py ├── tests.py └── views.py มาชี้แจงไฟล์ต่าง ๆ ที่สร้างขึ้นจนถึงขณะนี้ “config” คือชื่อโปรเจ็กต์ของเรา และตั้งชื่อตามแบบแผนเท่านั้น ภายใน config คุณจะได้รับ settings.py ซึ่งเป็นไฟล์ที่คุณตั้งค่าทั้งหมดของโปรเจ็กต์ของคุณ urls.py คือการกำหนดค่าโดยรวมของ URL ภายในโครงการ กำหนดเส้นทาง URL ของแอปพลิเคชันทั้งหมดภายในโครงการ
ไม่ต้องกังวลมากเกินไปเกี่ยวกับ asgi.py และ wsgi.py ไฟล์ ไฟล์เหล่านี้เป็นไฟล์ที่ให้คุณกำหนดค่าแอปพลิเคชันของคุณในการปรับใช้
manage.py เป็นสคริปต์หลามที่ให้คุณเรียกใช้คำสั่งที่มีอยู่ทั้งหมดของ Django-admin
เมื่อดูภายใน urlshortener ซึ่งเป็นชื่อของแอปที่คุณเพิ่งสร้างขึ้น คุณอาจสังเกตเห็นว่ามีโฟลเดอร์แปลก ๆ ที่เรียกว่า “migrations/” และไฟล์อื่นๆ บางไฟล์ที่มีความสำคัญต่อตรรกะของแอปใดๆ
apps.py เป็นที่ที่การกำหนดค่าแอพใช้งานได้ โดยปกติแล้ว คุณจะไม่ยุ่งกับมัน ยกเว้นแต่คุณกำลังทำสิ่งที่ค่อนข้างก้าวหน้า
admin.py คือที่ที่คุณลงทะเบียน โมเดล ของคุณเพื่อให้มองเห็นได้ในแผงผู้ดูแลระบบ Django
models.py คือสิ่งที่สำคัญที่สุด ภายในโมดูลนี้ คุณต้องกำหนด แบบจำลอง ซึ่ง (พูดอย่างคลุมเครือ) คือวิธีการจัดเก็บข้อมูล คุณจะได้ยินข้อมูลเพิ่มเติมเกี่ยวกับรุ่นต่างๆ ในภายหลัง
migrations/ คือโฟลเดอร์ที่จัดเก็บการโยกย้าย Django เราจะพิจารณาในเชิงลึกในภายหลัง
tests.py เป็นไฟล์ที่ใช้เก็บการทดสอบ เราจะไม่ครอบคลุมการทดสอบในบทช่วยสอนนี้
views.py เป็นไฟล์ที่เก็บมุมมอง โดยพื้นฐานแล้ว จะกำหนดวิธีที่ผู้ใช้จะโต้ตอบกับทุกแง่มุมของแอปของคุณ
การติดตั้งแอพ Django
ก่อนดำเนินการต่อ ให้เปิดไฟล์ settings.py และแก้ไขตัวแปร INSTALLED_APPS โดยเพิ่มแอป urlshortener
# Application definition INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', # Custom apps 'urlshortener', ]นี่เป็นขั้นตอนปกติเมื่อคุณสร้างแอป ดังนั้นทุกครั้งที่ทำ อย่าลืมติดตั้งในการตั้งค่าโปรเจ็กต์
ทำความเข้าใจกับรูปแบบ MVT
รูปแบบ Model, View, Template คือรูปแบบการออกแบบซอฟต์แวร์ที่นักพัฒนา Django ใช้เพื่อสร้างเว็บแอปพลิเคชัน
มันขึ้นอยู่กับ 3 แนวคิดหลัก โมเดล (ข้อมูล), มุมมอง (การโต้ตอบของผู้ใช้กับข้อมูล), เทมเพลต (วิธีที่ผู้ใช้ดูข้อมูล)
โมเดลคือคลาส Python ซึ่งกำหนดฟิลด์และพฤติกรรมทั้งหมดของข้อมูลที่คุณต้องการจัดเก็บ โดยปกติแต่ละรุ่นจะอ้างอิงถึงตารางที่ไม่ซ้ำกันในฐานข้อมูล
มุมมองในนิพจน์ที่ง่ายที่สุด คือ callable ที่รับคำขอจากผู้ใช้และสร้างการตอบกลับ ระหว่างกระบวนการนั้นเกิดตรรกะทางธุรกิจ ฉันรู้ว่า "ตรรกะทางธุรกิจ" เป็นแนวคิดที่ค่อนข้างคลุมเครือ ดังนั้นให้ฉันอธิบายว่ามันคืออะไร ตรรกะทางธุรกิจคือวิธีการสร้าง จัดเก็บ และลบข้อมูล นั่นคือทั้งหมด
สุดท้าย เทมเพลตคือเอกสารข้อความ (โดยปกติคือ Html) ที่แสดงให้ผู้ใช้เห็น โดยมีวัตถุประสงค์คือเพื่อนำเสนอข้อมูลที่สะอาดที่สุด Django รวมภาษาขนาดเล็กที่เรียกว่า Django template language (DTL) ซึ่งช่วยให้คุณรวมพลังของ python ไว้ในเอกสารข้อความ
สร้างแบบจำลอง Shortener
เมื่อคุณเข้าใจรูปแบบ MVT อย่างรวดเร็วแล้ว มาเริ่มสร้างตัวย่อ URL ของ Django กันดีกว่า
ก่อนอื่น มากำหนดรูปแบบย่อภายในไฟล์ models.py
''' Url shortener model ''' from django.db import models # Create your models here. class Shortener(models.Model): ''' Creates a short url based on the long one created -> Hour and date a shortener was created times_followed -> Times the shortened link has been followed long_url -> The original link short_url -> shortened link https://domain/(short_url) ''' created = models.DateTimeField(auto_now_add=True) times_followed = models.PositiveIntegerField(default=0) long_url = models.URLField() short_url = models.CharField(max_length=15, unique=True, blank=True) class Meta: ordering = ["-created"] def __str__(self): return f'{self.long_url} to {self.short_url}'ฉันรู้. เป็นชั้นเรียนที่ค่อนข้างใหญ่ มีสิ่งแปลก ๆ เกิดขึ้นมากมาย แต่อย่าสิ้นหวัง ฉันจะไปทีละขั้นตอนในสิ่งที่สำคัญแต่ละอย่าง
คำอธิบายแบบจำลอง
ก่อนอื่น เรานำเข้าโมดูล models โมดูลนี้มีฟังก์ชันทั้งหมดที่เราต้องการเพื่อสร้างโมเดล Django
เมื่อดูที่รุ่น “Shortener” สิ่งแรกที่ควรทราบก็คือมันขยาย models.Model ต่างๆ อันที่จริง โมเดลใดๆ ในแอพ Django ต้องเป็นคลาสย่อยของคลาส models.Model
จากนั้นเราจะกำหนดฟิลด์ทั้งหมดที่โมเดลจะมีในฐานข้อมูล ฟิลด์ "สร้าง" คือวันที่และเวลาที่ลิงก์แบบย่อถูกสร้างขึ้น ดังนั้นเราจึงใช้ DateTimeField เพื่อสร้างฟังก์ชันประเภทนี้ เราใช้อาร์กิวเมนต์ auto_now_add=True เนื่องจากเราต้องการให้แก้ไขฟิลด์เมื่อสร้างอินสแตนซ์เท่านั้น
ฟิลด์ที่สอง times_followed หมายถึงเวลาที่มีการใช้ URL แบบย่อ เป็น PositiveIntegerField และเราระบุค่าเริ่มต้นเป็นศูนย์ นั่นหมายความว่าทุกครั้งที่อินสแตนซ์สร้างฟิลด์ times_followed Django จะกรอกข้อมูลในฟิลด์นั้นด้วย 0
ในทางกลับกัน long_url หมายถึง URL ที่ผู้ใช้ป้อน เป็น URLField เนื่องจากเราต้องการให้ผู้ใช้ป้อนอักขระของแบบฟอร์มเท่านั้น: http://yoursite.com
ช่องสุดท้ายคือ short_url และมีรายละเอียดที่น่าสนใจ เราระบุว่ามีความยาวได้เพียง 15 อักขระเท่านั้น โดยต้องไม่ซ้ำกัน ซึ่งหมายความว่าจะไม่มีองค์ประกอบซ้ำในฟิลด์นั้น สุดท้ายนี้ เราระบุว่าสามารถเว้นว่างไว้ได้ ซึ่งหมายความว่าเมื่อทำงานกับแบบฟอร์ม ผู้ใช้จะไม่ต้องเขียนโค้ดย่อของตนเอง
คลาสชั้นในของ Meta บอกเราว่าคลาสต้องทำงานอย่างไร และเราตั้งค่าว่าการเรียงลำดับ (เรียก Shortener.objects.all() ) ของออบเจกต์ shortener จะถูกเลือกปฏิบัติโดยอันล่าสุด
วิธี __str__ จะบอกวิธีการพิมพ์แบบจำลอง ดังนั้นถ้าเรามีวัตถุที่มี long_url = “https://geekflare.com/” และย่อส่วน “123456” และเราพิมพ์ออกมา
https://geekflare.com/ to 123456ตอนนี้ได้เวลาค้นหาวิธีบันทึกลิงก์สั้น ๆ ด้วยวิธีสุ่ม
การสร้างฟังก์ชันย่อ
เราจะสร้าง 2 ฟังก์ชั่นที่กำหนดเอง อันแรกจะสร้างโค้ดแบบสุ่ม และอันที่สองจะป้องกันไม่ให้ได้รับโค้ดสุ่มซ้ำจากโมเดล Shortener ในการดำเนินการนี้ ให้สร้างไฟล์ utils.py ในแอป “urlshortener”
touch utils.pyภายในไฟล์นี้ เราจะใช้ฟังก์ชันเลือกจากโมดูลในตัวแบบสุ่ม สิ่งนี้อำนวยความสะดวกในการเลือกอักขระสุ่มเพื่อสร้างรหัส
''' Utilities for Shortener ''' from django.conf import settings from random import choice from string import ascii_letters, digits # Try to get the value from the settings module SIZE = getattr(settings, "MAXIMUM_URL_CHARS", 7) AVAIABLE_CHARS = ascii_letters + digits def create_random_code(chars=AVAIABLE_CHARS): """ Creates a random string with the predetermined size """ return "".join( [choice(chars) for _ in range(SIZE)] )ดังที่คุณเห็นว่าฟังก์ชันนี้จะคืนค่าสตริงสุ่มของความยาวที่ระบุในไฟล์การตั้งค่าหรือ 7 โดยค่าเริ่มต้น คุณกำลังใช้ฟังก์ชัน getattr เพื่อรับตัวแปรจากโมดูลการตั้งค่า แต่จะไม่มีข้อผิดพลาดเกิดขึ้นหากไม่มีการระบุตัวแปร
มาทำคณิตศาสตร์กันเถอะ หากเรามีสถานที่ 7 แห่ง ซึ่งแต่ละสถานที่สามารถมีอักขระได้มากถึง 62 ตัว การเรียงสับเปลี่ยนที่เป็นไปได้คือ:
จากการคำนวณอย่างรวดเร็วเหล่านี้ ส่วนที่สั้นลงสามารถกรอกรหัสต่างๆ ได้มากถึง 2.5 ล้านล้านรหัส ดังนั้นเราจึงลืมการสุ่ม URL ที่ย่อให้สั้นลงได้
แม้ว่าจะมีการเรียงสับเปลี่ยนมากมาย แต่ก็มีความเป็นไปได้เล็กน้อยที่จะได้ส่วนที่สั้นลงซ้ำๆ นี่เป็นปัญหาเนื่องจากเราตั้งค่าฟิลด์ shortened_url ให้ไม่ซ้ำกัน นั่นเป็นเหตุผลที่ฟังก์ชันต่อไปนี้มีประโยชน์มาก
def create_shortened_url(model_instance): random_code = create_random_code() # Gets the model class model_class = model_instance.__class__ if model_class.objects.filter(short_url=random_code).exists(): # Run the function again return create_shortened_url(model_instance) return random_code มาดูกันว่าเกิดอะไรขึ้นที่นี่ ฟังก์ชันนี้ใช้เป็นอาร์กิวเมนต์ของอินสแตนซ์โมเดล "Shortener" ขั้นแรก ฟังก์ชันจะสร้างโค้ดสุ่มโดยใช้ create_random_code จากนั้นจะได้รับ คลาส model และตรวจสอบว่ามีอ็อบเจ็กต์อื่นที่มี short_url เหมือนกัน short_url ไม่ ถ้ามันรันเองอีกครั้ง แต่ถ้าทุกอย่างเรียบร้อย มันจะส่งคืน random_code
หลังจากนั้น คุณจะโต้ตอบกับเชลล์ เพื่อดูฟังก์ชันนี้อย่างใกล้ชิด
หลังจากสร้างฟังก์ชันยูทิลิตี้แล้ว ลองใช้มันเพื่อสร้างรหัสสุ่มในโมเดลตัวย่อ
การปรับเปลี่ยนวิธีการบันทึก
ที่ส่วนท้ายของคลาส "Shortener" คุณจะต้องแก้ไขวิธีการบันทึกโมเดล วิธีการ บันทึก จะถูกเรียกทุกครั้งที่บันทึกวัตถุลงในฐานข้อมูล ดังนั้นเราจะมาดูวิธีใช้งานกันที่นี่
# Import the function used to create random codes from .utils import create_shortened_url # At the end of the Shortener model def save(self, *args, **kwargs): # If the short url wasn't specified if not self.short_url: # We pass the model instance that is being saved self.short_url = create_shortened_url(self) super().save(*args, **kwargs) วิธีการบันทึกกำลังถูกเขียนทับ ซึ่งหมายความว่าคุณกำลังแนะนำฟังก์ชันการทำงานใหม่ให้กับวิธีการหลักที่มีอยู่ก่อนแล้ว โดยทั่วไปเป็นการบอก Django ว่าทุกครั้งที่มีการบันทึกวัตถุ "Shortener" และไม่ได้ระบุ short_url วัตถุนั้นจะต้องเต็มไปด้วยรหัสสุ่ม
กำลังดำเนินการย้ายข้อมูล
ตอนนี้ได้เวลาสร้างและเรียกใช้การโยกย้ายโมเดล Shortener ในการทำเช่นนั้นให้รันคำสั่งต่อไปนี้ในโฟลเดอร์โปรเจ็กต์รูท
$ python manage.py makemigrations Migrations for 'urlshortener': urlshortener/migrations/0001_initial.py - Create model Shortener $ python manage.py migrate Operations to perform: Apply all migrations: admin, auth, contenttypes, sessions, urlshortener Running migrations: ...... # Apply the URL shortener migrations Applying urlshortener.0001_initial... OKสำหรับตอนนี้ คุณไม่ต้องกังวลว่าการย้ายข้อมูลคืออะไร พึงระลึกไว้เสมอว่าเมื่อรันคำสั่งทั้งสองนี้ Django จะสร้างไฟล์ฐานข้อมูล db.sqlite ตามรุ่นที่คุณกำหนด
มาสร้างวัตถุด้วยเปลือก Django กันเถอะ
$ python manage.py shell >>> from urlshortener.models import Shortener >>> s = Shortener(long_url="https://geekflare.com") >>> s.short_url '' >>> s.save() >>> s.short_url 'kdWFVIc' >>> s.long_url 'https://geekflare.com' >>> print(s) https://geekflare.com to kdWFVIcนั่นเป็นวิธีที่วัตถุที่สั้นกว่าทั้งหมดจะทำงาน
การเขียนมุมมอง
อย่างที่ฉันพูดไปก่อนหน้านี้ มุมมองเป็นฟังก์ชันง่ายๆ ที่รับคำขอและส่งคืนการตอบกลับ เรามาดูวิธีการสร้างมุมมองโลกสวัสดีกัน
การตอบสนองเทมเพลตพื้นฐาน
ภายในไฟล์ “urlshortener/views.py” สร้างฟังก์ชัน home_view อ้า
''' Shortener views ''' from django.shortcuts import render, get_object_or_404 # We will use it later from django.http import HttpResponse # Create your views here. def home_view(request): return HttpResponse("Hello world")มันส่งกลับข้อความง่าย ๆ “สวัสดีชาวโลก” ต่อมาคุณจะเห็นว่าหน้าตาเป็นอย่างไรในเบราว์เซอร์ ตอนนี้สร้าง "urls.py" แล้วจะมีรูปแบบ URL ทั้งหมดของแอป
touch urls.py
เพิ่มรหัสต่อไปนี้
''' Urls for shortener app urlshortener/urls.py ''' from django.urls import path # Import the home view from .views import home_view appname = "shortener" urlpatterns = [ # Home view path("", home_view, name="home") ]ตัวแปร APPNAME ประกาศ (เป็นชื่อแนะนำ) namespacing ของ app urlshortener ที่
อธิบายอย่างรวดเร็วว่าเรากำลังนำเข้าฟังก์ชันเส้นทาง ซึ่งจะส่งคืนองค์ประกอบที่จะรวมไว้ในรูปแบบ URL ของแอป แอตทริบิวต์ ชื่อ คือเนมสเปซของพาธ ซึ่งสามารถเรียกภายในเทมเพลตได้หากจำเป็น
ตอนนี้ มาแก้ไข URL ของโปรเจ็กต์โดยรวมกัน
# config/urls.py from django.contrib import admin from django.urls import path, include urlpatterns = [ path('admin/', admin.site.urls), # Shortener Urls path('', include('urlshortener.urls')) ]ตอนนี้เรามาเปิดเซิร์ฟเวอร์กันอีกครั้ง
python manage.py runserverหากคุณเปิดเซิร์ฟเวอร์ คุณจะได้รับข้อความ "สวัสดีชาวโลก" แบบง่ายๆ เนื่องจากคุณกำลังรวม urlpatterns จากแอปตัวย่อ URL ไว้ในโปรเจ็กต์โดยรวม
นี่เป็นเพียงจุดเริ่มต้น ตอนนี้ได้เวลาสร้างแบบฟอร์มเพื่อให้ผู้ใช้สร้าง Shortened URL ด้วยตนเอง
การสร้างแบบฟอร์ม
ใน Django แบบฟอร์มคือคลาสง่าย ๆ ที่อนุญาตให้รับอินพุตจากผู้ใช้
คุณกำลังจะสร้างไฟล์ form.py เป็นข้อตกลงในการจัดเก็บทุกรูปแบบของแอพในไฟล์นั้น
cd urlshortener/ touch forms.pyภายในไฟล์นั้น คุณจะสร้างคลาส “ShortenerForm” ซึ่งขยายจาก “ModelForm”
''' Shortener Forms urlshortener/forms.py ''' from django import forms from .models import Shortener class ShortenerForm(forms.ModelForm): long_url = forms.URLField(widget=forms.URLInput( attrs={"class": "form-control form-control-lg", "placeholder": "Your URL to shorten"})) class Meta: model = Shortener fields = ('long_url',)เป็นรูปแบบโมเดลเนื่องจากมีวัตถุประสงค์เพื่อสร้างโมเดลวัตถุจากอินพุตของผู้ใช้ เรายังใช้ประโยชน์จากอาร์กิวเมนต์วิดเจ็ต ซึ่งช่วยให้เราระบุแอตทริบิวต์ "คลาส" (คลาสใน CSS ไม่ใช่ python) นี่เป็นเพราะว่าเราจะปรับแต่งแอปด้วยบูตสแตรปในภายหลัง
จบการรับชม
หลังจากสร้างแบบฟอร์มแล้วก็ถึงเวลาสร้างตรรกะทางธุรกิจขั้นสุดท้ายของแอปพลิเคชัน
ไปที่ไฟล์ views.py ภายในแอป shortener และแก้ไขมุมมอง home_view คุณสามารถตรวจสอบ Github repo ได้ในขณะนี้เพื่อทำความเข้าใจว่าโครงสร้างโครงการเป็นอย่างไร
มีสองมุมมองสำหรับแอปตัวย่อ URL:
- มุมมองหน้าแรก: แสดงแบบฟอร์มย่อและ URL ใหม่หากส่งแบบฟอร์มแล้ว
- มุมมองเปลี่ยนเส้นทาง: เปลี่ยนเส้นทางไปยัง URL แบบยาวและเพิ่ม 1 ตามเวลาที่ตามมา
เริ่มกันที่โฮมวิวซึ่งซับซ้อนที่สุด คุณจะต้องนำเข้าโมเดลและแบบฟอร์ม Shortener คุณยังคงใช้ฟังก์ชันอยู่ เนื่องจากฉันต้องการให้คุณเข้าใจโฟลว์ข้อมูลทั้งหมดของมุมมอง นอกจากนี้ คุณจะใช้เส้นทางสำหรับเทมเพลต (ซึ่งยังไม่ได้สร้าง)
หน้าแรก ดู
''' Shortener views ''' from django.shortcuts import render # We will use it later from django.http import HttpResponse, Http404, HttpResponseRedirect # Model from .models import Shortener # Custom form from .forms import ShortenerForm # Create your views here. def home_view(request): template = 'urlshortener/home.html' context = {} # Empty form context['form'] = ShortenerForm() if request.method == 'GET': return render(request, template, context) elif request.method == 'POST': used_form = ShortenerForm(request.POST) if used_form.is_valid(): shortened_object = used_form.save() new_url = request.build_absolute_uri('/') + shortened_object.short_url long_url = shortened_object.long_url context['new_url'] = new_url context['long_url'] = long_url return render(request, template, context) context['errors'] = used_form.errors return render(request, template, context)มุมมองจะขึ้นอยู่กับสองเงื่อนไข:
- เมื่อเมธอด HTTP เท่ากับ GET: เราส่งผ่านเป็นบริบทเท่านั้น รูปแบบ Shortener ที่ใช้สร้างออบเจ็กต์ Shortener
- เมื่อวิธี HTTP เท่ากับ POST: เรายังคงส่งแบบฟอร์มในบริบทเนื่องจากเราต้องการให้ผู้ใช้ป้อน URL อื่นได้ แต่เรากำลังส่งคำขอ Post ไปยังแบบฟอร์มอื่นที่เรียกว่า used_form
วิธีที่ยุ่งยากในการรับ URL ของไซต์ที่สมบูรณ์แบบไดนามิกคือการใช้เมธอดของ request object build_absolute_uri
>>> print(request.build_absolute_uri('/')) 'https://localhost:8080/'เพื่อความปลอดภัยในการประมวลผลคำขอที่ไม่ถูกต้อง (ผู้ใช้ไม่ได้ป้อน URL ที่ถูกต้อง) เราได้รับข้อผิดพลาดของแบบฟอร์ม ส่งต่อเป็นบริบทและแสดงเทมเพลตตามปกติ หลังจากนั้น คุณจะเห็นวิธีการใช้การแสดงข้อผิดพลาดในเทมเพลต
มุมมองเปลี่ยนเส้นทาง
redirect_url_view นั้นง่ายกว่าเล็กน้อย เป็นมุมมองรายละเอียดซึ่งหมายความว่ามุมมองใช้งานได้กับวัตถุเท่านั้น
ฟังก์ชันนี้ใช้เป็นพารามิเตอร์ คำขอของผู้ใช้ และ shortened_part ของ URL ไม่จำเป็นต้องยืนยันประเภทคำขอที่เราได้รับ เนื่องจากเราไม่ได้ทำงานกับแบบฟอร์มในมุมมองนี้
def redirect_url_view(request, shortened_part): try: shortener = Shortener.objects.get(short_url=shortened_part) shortener.times_followed += 1 shortener.save() return HttpResponseRedirect(shortener.long_url) except: raise Http404('Sorry this link is broken :(') เราปกป้องมุมมองด้วยคำสั่ง ลอง/ยกเว้น ในกรณีที่ไม่พบส่วนที่สั้นลงในฐานข้อมูล หากพบวัตถุจะเพิ่ม 1 ลงในฟิลด์ times_followed และเปลี่ยนเส้นทางด้วยฟังก์ชัน HttpResponseRedirect ไปยัง URL ของไซต์ที่สอดคล้องกับโค้ดสุ่ม
กำลังอัปเดต URL
เมื่อคุณสร้างสองมุมมองของแอปแล้ว ก็ถึงเวลาสร้างรูปแบบ URL สุดท้ายโดยรวมเส้นทางไปยัง redirect_url_view
เช่นเคย คุณเริ่มต้นด้วยการนำเข้ามุมมอง จากนั้นสร้างฟังก์ชันเส้นทางและส่งผ่านเป็นอาร์กิวเมนต์:
- เส้นทาง URL
- จุดชมวิวที่ชี้ไปยังเส้นทาง
- ชื่อเส้นทาง
''' Urls for shortener app urlshortener/urls.py ''' from django.urls import path # Import the home view from .views import home_view, redirect_url_view appname = "shortener" urlpatterns = [ # Home view path('', home_view, name='home'), path('<str:shortened_part>', redirect_url_view, name='redirect'), ]ด้วยการตั้งค่า URL นี้ การกำหนดเส้นทางของแอปจะมีลักษณะดังนี้
-
localhost:8000/: มุมมองหน้าแรก -
localhost:8000/URL-code: เปลี่ยนเส้นทางไปยัง URL แบบยาว
การสร้างเทมเพลต
คุณเกือบจะอยู่ที่นั่นแล้ว สิ่งเดียวที่แยกคุณออกจากการสร้างแอพนี้คืออินเทอร์เฟซผู้ใช้ เพื่อที่เราใช้เทมเพลต Django
เทมเพลตใช้เพื่อแสดงอินเทอร์เฟซที่สะอาดสำหรับผู้ใช้แอป ไฟล์เหล่านี้สร้างขึ้นภายในแอปในโครงสร้างโฟลเดอร์คู่ของแบบฟอร์ม: “เทมเพลต/ชื่อแอป”
# urlshortener directory mkdir -p templates/urlshortener/หมายเหตุ: โครงสร้างโฟลเดอร์คู่และภาษาเทมเพลต Django อยู่นอกเหนือขอบเขตของบทช่วยสอนนี้ แต่คุณสามารถอ่านเกี่ยวกับโครงสร้างเหล่านี้ได้ในเอกสารประกอบอย่างเป็นทางการ
แม่แบบฐาน
Django อนุญาตให้สืบทอดเทมเพลต ซึ่งหมายความว่าเราสามารถมีเทมเพลตพื้นฐานและขยายได้โดยมีวัตถุประสงค์เพื่อปฏิบัติตามหลักการดราย (อย่าทำซ้ำตัวเอง)
cd templates/urlshortener touch base.htmlไฟล์ base.html เป็นแบบแผนและหมายความว่าทุกเทมเพลตอื่น ๆ ในแอปจะต้องเป็นส่วนขยายของเทมเพลตนี้
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8" /> <meta http-equiv="X-UA-Compatible" content="IE=edge" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /> <title>Django Url shortener</title> <link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-wEmeIV1mKuiNpC+IOBjI7aAzPcEZeedi5yW5f2yOq55WWLwNGmvvx4Um1vskeMj0" crossorigin="anonymous" /> <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.3/css/all.min.css" integrity="sha512-iBBXm8fW90+nuLcSKlbmrPcLa0OT92xO1BIsZ+ywDWZCvqsWgccV3gFoRBv0z+8dLJgyAHIhR35VZc2oM/gI1w==" crossorigin="anonymous" /> </head> <body> {% block body %} {% endblock body %} <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.bundle.min.js" integrity="sha384-p34f1UUtsS3wqzfto5wAAmdvj+osOnFyQFpp4Ua3gs/ZVWx6oOypYoCJhGGScy+8" crossorigin="anonymous" ></script> </body> </html>เราจะใช้บูตสแตรป CDN เพื่อสร้างอินเทอร์เฟซที่รวดเร็วและสวยงามโดยไม่ต้องใช้ไฟล์ CSS หรือจาวาสคริปต์
หากคุณต้องการเรียนรู้อย่างลึกซึ้งเกี่ยวกับแท็ก DTL คุณสามารถทำได้ด้วยเอกสารอย่างเป็นทางการ
แม่แบบหน้าแรก
โฮมเทมเพลต สืบทอดมาจากไฟล์ base.html นั่นหมายความว่าเทมเพลตนี้มี HTML ทั้งหมดจากไฟล์หลัก
{% extends 'urlshortener/base.html' %} {% block body %} <div class="container"> <div class="card mt-5"> <div class="card-header text-center py-3"> <h1>URL Shortner Application <i class="fas fa-link px-2"></i></h1> </div> <div class="px-3 py-4"> <form action="" method="POST"> {% csrf_token %} <div class="row g-1"> <div class="col-10">{{form.long_url}}</div> <div class="col-2"> <button class="btn btn-success btn-lg w-100" type="submit"> Shorten </button> </div> </div> </form> </div> </div> {% if errors %} <div class="alert alert-danger mt-4" role="alert"> <p>{{errors}}</p> </div> {% endif %} {% if new_url %} <div class="mx-auto text-center mt-5"> <h2 class="text-danger">Your shortened Url</h2> <p>You can copy the Link below and share it with your friends</p> <p class="">{{new_url}}</p> <p><span class="text-danger">Previous URL:</span> {{long_url}}</p> </div> {% endif %} </div> {% endblock body %}ฉันจะอธิบายโฟลว์ข้อมูลของเทมเพลตนี้อย่างรวดเร็ว:
- แบบฟอร์ม Shortener จะปรากฏขึ้น ภายในมีการตั้งค่าโทเค็น crsf (เหตุผลด้านความปลอดภัย) และจะแสดงเฉพาะฟิลด์ URL แบบยาวของแบบฟอร์มเท่านั้น โปรดจำไว้ว่าฟิลด์นี้มีคลาส CSS "form-control form-control-lg" เพราะเราตั้งค่านั้นในแบบฟอร์ม
- หากพบข้อผิดพลาดให้แสดง
- หากการดำเนินการ POST สำเร็จ URL ใหม่จะแสดงขึ้น
การสมัครครั้งสุดท้าย
ยินดีด้วย! . คุณได้สร้างแอปตัวย่อ URL ที่ใช้งานได้อย่างสมบูรณ์ด้วย Django
นี่คือภาพหน้าจอบางส่วนที่แสดงให้เห็นว่าแอปพลิเคชันมีลักษณะอย่างไร
รับเท่านั้น:
เกิดข้อผิดพลาดในการย่อ URL:
URL ที่ย่อสำเร็จ:
URL เปลี่ยนเส้นทาง:
คุณคิดอย่างไรกับการเปิดเผยตัวอย่างแอปย่อ URL นี้ให้ผู้อื่นทราบ ตรวจสอบวิธีเปิดเผยแอพ Django Demo สู่อินเทอร์เน็ต
ท้าทาย
หากคุณรู้สึกสบายใจกับทักษะ Django ของคุณ ทำไมไม่ลองฝึกกับความท้าทายดูล่ะ?
ลอกแบบรหัสของแอปพลิเคชันนี้และสร้างระบบการตรวจสอบสิทธิ์ ซึ่งมีเพียงผู้ใช้ที่ลงทะเบียนเท่านั้นที่สามารถย่อ URL ของตนได้
เมื่อคุณทำเสร็จแล้ว ส่งคำขอดึงและ ping ฉันบน Twitter เพื่อแสดงความสำเร็จของคุณ
ห่อ
คุณมาถึงจุดสิ้นสุดของบทช่วยสอนนี้แล้ว เชื่อหรือไม่ คุณเพิ่งทบทวนประเด็นหลักทั้งหมดในการสร้างโปรเจ็กต์ Django ฉันหวังว่าคุณจะพบว่ามีประโยชน์อย่างมาก
ในบทช่วยสอนนี้ คุณ:
- เรียนรู้เกี่ยวกับเวิร์กโฟลว์ในการสร้างแอพ Django
- สร้างโครงการเรซูเม่
- เข้าใจความแตกต่างและโครงสร้างของโปรเจ็กต์ Django และแอป Django
- ค้นพบรูปแบบ MVT
- สร้างมุมมองฐานฟังก์ชัน
- ใช้ Django ORM (Object Relational Mapper) เพื่อสร้างแบบจำลองอย่างง่าย
นั่นคือทั้งหมด มีหลายสิ่งที่ต้องครอบคลุมเกี่ยวกับเฟรมเวิร์กเว็บของ Django ดังนั้นโปรดติดต่อสำหรับบทช่วยสอนที่น่าทึ่งเพิ่มเติม