Django 101 Ep.3 Django MVT; Model, View, Template.

MTV Overview
MVT Concept

Model → คือส่วนที่ใช้ติดต่อกับ Database สร้างตารางต่าง ๆ

View → คือส่วนที่เป็น Business Logic ของโปรเจคท์ ใช้เขียนฟังก์ชันต่าง ๆ แล้วส่งข้อมูลออกไปที่ Template

Template → ส่วนที่แสดงผลหน้าเว็บและข้อมูลต่าง ๆ ที่ได้มาจาก View

จากคำนิยามสั้น ๆ ด้านบน ซึ่งผมจะขออธิบายเพื่อให้เข้าใจภาพรวมว่าแต่ละส่วนทำหน้าที่อย่างไร ซึ่งผมจะขออธิบายลงรายละเอียดดังต่อไปนี้

Model

คือส่วนที่ใช้ติดต่อกับ Database เช่นเมื่อเราได้ทำการสร้างตารางขึ้นมา การสร้างตารางเพื่อที่จะ Migrate ไปที่ Database นั้น จะเห็นได้ว่าจะมีการใช้ตัว Class, Object ปกติเหมือนเขียนไพธอนโดยทั่วไป ซึ่งส่วนนี้เราจะเรียกว่า ORM(Object Relational Mapper) ซึ่งโดยที่เราสามารถเขียนโปรแกรมเพื่อติดต่อกับ Database โดยที่ไม่ต้องเขียนภาษา SQL แม้แต่คำสั่งเดียว แต่จะใช้ตัว ORM ในการติดต่อแทน ซึ่งเรียกได้ว่ามีความสะดวกมาก ๆ หลังจากที่ได้ทำการสร้าง class, object ต่าง ๆ ใน Model จากนั้นเราก็จะสามารถ import ไปใช้งานได้อย่างที่มีการ import กันตามปกติในไพธอน

ORM รายละเอียดเชิงลึกเป็นอย่างไร ติดตามต่อได้ใน Ep.5 Django ORM

models.py example code

models.py

from django.db import models


# Create your models here.
class HollywoodStar(models.Model):
name = models.CharField(max_length=80)
age = models.IntegerField()
ตารางที่สร้างขึ้นจาก Model

จากตัวอย่างตาราง Hollywood Star ด้านบนที่ถูกสร้างขึ้นโดย model และถูก migrate ไปที่ตัว Database เรียบร้อย จากนั้นผมได้ทำการบันทึกข้อมูลเข้าไปในตารางที่สร้างขึ้นมาโดยมีจำนวน 2 แถวเพื่อทดสอบ

View

จากคำนิยามที่ผมได้บอกว้ด้านบน ว่าส่วนนี้เป็น Business Logic เรียกง่าย ๆ ได้ว่า คือส่วนที่เอาไว้เขียนฟังก์ชันก์ต่าง ๆ จัดการกับข้อมูลใน Model เช่นการ Query ข้อมูลมาจัดการ จากนั้นจะนำข้อมูลไปทำอะไร เช่น Create, Update, Delete, Read ก็สามารถเขียนฟังก์ชันได้ตามต้องการ โดยส่วนนี้จะมีทั้งการรับข้อมูล Input มาจาก User ผ่าน Template และก็มีทั้งการส่งต่อหรือ Return ข้อมูลออกไปแสดงผลที่ฝั่ง Template ซึ่งเรียกได้ว่าโพรเซสตรงส่วนของ View นอกจากจะมีการส่งข้อมูลออกไปแสดงผลที่ฝั่ง Template ยังมีการรับข้อมูลจาก User ในฝั่ง Template เช่นการรับ Request จาก User ที่มีการร้องขอข้อมูลเข้ามา (การติดต่อกันระหว่าง Client และ Server จะใช้ HTTP Protocol) จากนั้นก็จะไปตรวจสอบข้อมูลว่าใน Database มีข้อมูลตามที่ User ร้องขอมาหรือไม่ จากนั้นก็จะ Response ออกไปที่ฝั่ง Template ซึ่งเรียกได้ว่าเป็น Cycle ของ HTTP Request, Response ก็ว่าได้

HTTP Request, Reponse คืออะไร ติดตามกันได้ใน Ep.6 Django with HTTP Request, Response

views.py example code

views.py

from django.shortcuts import render
from .models import HollywoodStar


# Create your views here.
def show_info(request):
obj = HollywoodStar.objects.all()
return render(request, 'home.html', {'context': obj})

จากโค้ดด้านบนจะสังเกตเห็นว่าผมได้ทำการ Query ข้อมูลมาจาก Model ซึ่งคำสั่งด้านบนผมจะ Query มาทั้งหมด แล้วเก็บไว้ในต้วแปร obj จากนั้นก็จะทำการรีเทิร์น ข้อมูลชุดนี้ออกไปที่ฝั่ง Template เพื่อแสดงผลต่อไป โดยข้อมูลที่ผมรีเทิร์นออกไปจะแทนที่ด้วยตัวแปร context ซึ่งข้อมูลทั้งหมดจะถูกเก็บอยู่ในรูปแบบของ Dictionary

Template

ส่วนนี้คือส่วนที่เรียกได้อีกอย่างหนึ่งว่าเป็นส่วนหน้าบ้าน หรือฝั่งที่เอาไว้ใช้แสดงผลนั่นเอง ซึ่งจะมีการรอรับฟังก์ชันต่าง ๆ จาก View ซึ่งจะถูกส่งไปในรูปแบบ Context ให้มองว่า Context คือตัวแปรตัวหนึ่งที่เก็บฟังก์ชันหรือคำสั่งต่าง ๆ เอาไว้ ซึ่งฟังก์ชันและคำสั่งเหล่านี้คล้ายกับว่าจะถูก Wrap ไว้เรียบร้อยจากฝั่ง View จากนั้นตัว Template จะนำตัว Context ออกไปจัดการหรือแสดงผลอย่างไร ก็สามารถทำได้ตามต้องการ ซึ่งการที่จะนำตัวแปรเหล่านี้ไปใช้งานในหน้า HTML ฝั่ง Template จะไม่สามารถนำไปเขียนได้ตรง ๆ เนื่องจากว่าตัวภาษา Python และ HTML ก็แน่อยู่แล้วว่าเป็นคนละภาษา ดังนั้นจึงต้องมีตัวกลางที่จะสามารถทำให้ตัว HTML รู้จักกับภาษาไพธอนได้ ซึ่งตัวกลางที่ว่ามานี้คือ Django Template นั่นเอง ซึ่งถ้าใครเคยเขียน Flask มาแล้วมาเจอกับ Django Template ซึ่งในตัว Django Template นั้นจะประกอบไปด้วย Tag และ Variable และจะเห็นได้ว่า แทบไม่มีความแตกต่างกันเพราะมีความคล้ายคลึงกันมาก(แต่ก็คนละตัวกันนะ)

Django Template คืออะไร ติดตามได้ใน Ep.7 Django Template (Tag and Variable)

template(home.html)

home.html

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title> Home </title>
</head>
<body>

{% for data in context %}
<p> The first HollyWood star is: <p style="color: darkblue">{{ data.name }}</p></p>
<p> Age: <p style="color: darkblue">{{ data.age }}</p></p>
{% endfor %}

</body>
</html>
ข้อมูลใน Model ถูกดึงมาแสดงผลที่ Template โดยผ่านตัว View แล้วส่งค่ากลับมาแสดงผลที่ Template

จากโค้ดด้านบนจะเห็นว่าผมได้ทำการใช้ for loop เขียนเข้าไปใน Django Template Tag {% for data in context %} จากนั้นเมื่อข้อมูลมารออยู่ส่วนนี้แล้ว ผมก็จะทำการแสดงผลข้อมูลโดยใช้ Django Template Variable {{ data.name }} และ {{ data.age }} ซึ่งเมื่อทำการรันเซิร์ฟเวอร์ ข้อมูลก็จะแสดงผลออกมาแบบไดนามิก นั่นก็คือเมื่อข้อมูลมีการเปลี่ยนแปลง เช่น มีการเพิ่ม, แก้ไข, ลบ ข้อมูลของเราที่อยู่ใน Database ข้อมูลก็จะแสดงผลขึ้นมาอัตโนมัติ โดยที่เรา ไม่ต้องทำการแก้ไขโค้ดตรงส่วนนี้

สรุป

จบไปแล้วครับกับบทความ Django Design Patterns; Model, View, Template. โดยเมื่ออ่านบทความนี้จบ คุณจะสามารถ

  1. เข้าใจคอนเซ็ปต์และสามารถอธิบาย Django MVT ว่าแต่ละส่วนคืออะไร ทำงานร่วมกันได้อย่างไร
  2. เข้าใจและสามารถอธิบาย Model ได้
  3. เข้าใจและสามารถอธิบาย View ได้
  4. เข้าใจและสามารถอธิบาย Template ได้

ถ้าชื่นชอบบทความนี้ ก็อย่าลืมกด Clap คนละ Clap เพื่อเป็นกำลังใจในการสร้างสรรค์ผลงานด้วยนะครับ หรือจะแชร์ไปให้เพื่อน ๆ ก็จะขอบคุณมาก หรือมีข้อแนะนำ ติชมตรงไหน ก็คอมเมนต์ได้ที่ด้านล่างโพสต์ไว้ได้เลยครับ See ya next article.

Sonny STACKPYTHON

Full Stack Python Developers