Scala for Backend Engineering & Functional Programming · บทเรียน

การสร้าง RESTful API ด้วย Play

ออกแบบและสร้างจุดปลายทาง RESTful จัดการคำขอ และจัดการข้อมูล JSON ด้วยตัวควบคุมของ Play

การสร้าง RESTful API ด้วย Play เป็นบทเรียน Scala for Backend Engineering & Functional Programming ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 3 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Scala for Backend Engineering & Functional Programming และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 3 บทเรียน

บทนำสู่ REST API ของ Play

ยินดีต้อนรับ! ในบทเรียนนี้ เราจะเจาะลึกการสร้าง RESTful API โดยใช้ Scala Play Framework REST (Representational State Transfer) คือรูปแบบสถาปัตยกรรมที่ใช้กันอย่างแพร่หลายสำหรับการออกแบบแอปพลิเคชันบนเครือข่าย

RESTful API ช่วยให้ระบบซอฟต์แวร์ต่าง ๆ สื่อสารระหว่างกันผ่านอินเทอร์เน็ต โดยทั่วไปจะใช้เมธอด HTTP มาตรฐาน เช่น GET, POST, PUT และ DELETE เพื่อดำเนินการกับทรัพยากร

ตัวควบคุมและการดำเนินการของ Play

ใน Play คำขอ HTTP ขาเข้าจะได้รับการจัดการโดย ตัวควบคุม ตัวควบคุมคืออ็อบเจ็กต์หรือคลาส Scala ที่มี เมธอดการดำเนินการ

เมธอดการดำเนินการแต่ละเมธอดมีหน้าที่ประมวลผลคำขอประเภทหนึ่งโดยเฉพาะ (เช่น ดึงข้อมูลหรือสร้างรายการใหม่) และส่งคืนการตอบกลับ HTTP

การกำหนดเส้นทางใน Play

Play ใช้ไฟล์ conf/routes เพื่อจับคู่คำขอ HTTP ขาเข้ากับเมธอดการดำเนินการของตัวควบคุมที่ระบุ ซึ่งเป็นจุดที่คุณกำหนดปลายทางของ API

ไวยากรณ์พื้นฐานของรายการเส้นทางคือ: HTTP_METHOD /path controllers.ControllerName.actionMethod(parameters)

การสร้างปลายทาง GET

มาสร้างปลายทาง GET อย่างง่ายที่ส่งคำทักทายกลับ ในแอป Play จริง โค้ดนี้จะอยู่ภายในตัวควบคุม แต่ในที่นี้เราจะจำลองตรรกะในเมธอด main

ลองเรียกใช้ตัวอย่างนี้:

object GreetingController {
  // This method simulates a Play controller action
  def sayHello(): String = {
    "Hello from your Play API!"
  }
  
  def main(args: Array[String]): Unit = {
    // Simulate receiving a request and calling the action
    val apiResponse = sayHello()
    println(s"Simulated API Response: $apiResponse")
  }
}

การดึงพารามิเตอร์จากพาธ

บ่อยครั้งคุณจำเป็นต้องดึงค่าแบบไดนามิกจากพาธ URL เช่น ID ของรายการ ค่าเหล่านี้เรียกว่า พารามิเตอร์พาธ

ในไฟล์ routes คุณกำหนดพารามิเตอร์เหล่านี้ด้วยเครื่องหมายโคลอน (:) ส่วนในการดำเนินการของตัวควบคุม คุณประกาศพารามิเตอร์เหล่านี้เป็นพารามิเตอร์ของเมธอด

object UserController {
  // This action takes an 'id' as a path parameter
  def getUser(id: Int): String = {
    s"Fetching user details for ID: $id"
  }
  
  def main(args: Array[String]): Unit = {
    // Simulate a request to /users/123
    val userIdFromRequest = 123
    val apiResponse = getUser(userIdFromRequest)
    println(s"Simulated API Response: $apiResponse")
  }
}

เนื้อหาคำขอและ JSON

สำหรับการสร้างหรืออัปเดตทรัพยากร ไคลเอนต์จะส่งข้อมูลมาใน เนื้อหาคำขอ สำหรับ RESTful API ข้อมูลนี้มักอยู่ในรูปแบบ JSON (JavaScript Object Notation)

Play รองรับการแยกวิเคราะห์เนื้อหาคำขอ JSON และแปลงเป็นคลาสกรณีของ Scala ได้เป็นอย่างดี

การสร้างปลายทาง POST

มาจำลองปลายทาง POST ที่รับเนื้อหา JSON ในแอป Play จริง คุณจะใช้ไลบรารี JSON ของ Play เพื่อแยกวิเคราะห์คำขอ แต่สำหรับตัวอย่างที่เรียกใช้ได้นี้ เราจะตรวจสอบเนื้อหาสตริงอย่างง่าย

ลองเรียกใช้ตัวอย่างนี้:

object ItemController {
  // Simulate processing a JSON request body
  def createItem(jsonBody: String): String = {
    // In a real Play app: Json.parse(jsonBody).as[ItemCaseClass]
    if (jsonBody.contains("name") && jsonBody.contains("price")) {
      s"Item successfully created! Data: $jsonBody"
    } else {
      "Error: Invalid JSON format. 'name' and 'price' expected."
    }
  }
  
  def main(args: Array[String]): Unit = {
    // Simulate a POST request with a JSON body
    val validJson = """{"name": "Smartphone", "price": 799.99}"""
    println(s"Valid JSON Response: ${createItem(validJson)}")
    
    val invalidJson = """{"product": "Tablet"}"""
    println(s"Invalid JSON Response: ${createItem(invalidJson)}")
  }
}

การจัดการ PUT และ DELETE

นอกจาก GET และ POST แล้ว RESTful API มักใช้:

PUT: ใช้อัปเดตทรัพยากรที่มีอยู่ โดยทั่วไปต้องใช้พารามิเตอร์พาธ (ID) และเนื้อหาคำขอ (ข้อมูลที่อัปเดตแล้ว)
DELETE: ใช้ลบทรัพยากร โดยทั่วไปต้องใช้เพียงพารามิเตอร์พาธ (ID)

รูปแบบการกำหนดเส้นทางและการเข้าถึงพารามิเตอร์หรือเนื้อหาสำหรับ PUT และ DELETE คล้ายกับ POST และ GET

การส่งคืนการตอบกลับ JSON

หลังจากประมวลผลคำขอแล้ว โดยทั่วไป API ของคุณต้องส่งการตอบกลับกลับไป ซึ่งมักอยู่ในรูปแบบ JSON Play ช่วยให้สร้างอ็อบเจ็กต์ JSON และส่งกลับไปได้อย่างง่ายดาย

ในตัวควบคุม โดยทั่วไปคุณจะใช้ Ok(Json.toJson(yourCaseClass)) ส่วนในที่นี้ เราจะจำลองการสร้างสตริง JSON

object ResponseGenerator {
  // Simulate a case class for the response data
  case class ApiResponse(status: String, message: String)

  // Simulate converting the case class to a JSON string
  def buildJsonResponse(response: ApiResponse): String = {
    s"""{"status": "${response.status}", "message": "${response.message}"}"""
  }

  def main(args: Array[String]): Unit = {
    val successResponse = ApiResponse("success", "Data retrieved successfully")
    println(s"Simulated JSON Output:\n${buildJsonResponse(successResponse)}")

    val errorResponse = ApiResponse("error", "Item not found")
    println(s"Simulated JSON Output:\n${buildJsonResponse(errorResponse)}")
  }
}

แบบทดสอบการจับคู่เส้นทาง

คำจำกัดความเส้นทางของ Play ใดที่จะจับคู่กับคำขอ GET /api/products/123 ได้อย่างถูกต้อง และส่ง 123 เป็นค่า Int ไปยังการทำงานของ controller

ทบทวนและขั้นตอนถัดไป

ทำได้ดีมากครับ/ค่ะ! คุณได้เรียนรู้พื้นฐานการสร้าง RESTful API ด้วย Play Framework แล้ว:

ทำความเข้าใจ หลักการของ RESTful และเมธอด HTTP
วิธีที่ controller และการทำงานของ Play ประมวลผลคำขอ
การกำหนด เส้นทาง API เพื่อจับคู่ URL กับการทำงานของ controller
การดึง พารามิเตอร์ในเส้นทาง จาก URL
การจัดการ เนื้อหาคำขอแบบ JSON สำหรับ POST/PUT
การสร้างและส่งกลับ การตอบกลับแบบ JSON

ขั้นถัดไป คุณอาจลองศึกษาเรื่องการเชื่อมต่อฐานข้อมูลกับแอปพลิเคชัน Play ของคุณ!

คำถามที่พบบ่อย

บทเรียน “การสร้าง RESTful API ด้วย Play” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การสร้าง RESTful API ด้วย Play” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Scala for Backend Engineering & Functional Programming ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 3 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การสร้าง RESTful API ด้วย Play”

ออกแบบและสร้างจุดปลายทาง RESTful จัดการคำขอ และจัดการข้อมูล JSON ด้วยตัวควบคุมของ Play คุณปฏิบัติ Scala for Backend Engineering & Functional Programming ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Scala for Backend Engineering & Functional Programming หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Scala for Backend Engineering & Functional Programming บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 3 บทเรียน

บทเรียน “การสร้าง RESTful API ด้วย Play” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Scala for Backend Engineering & Functional Programming นี้ได้ไหม

ได้ บทเรียน Scala for Backend Engineering & Functional Programming ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Scala for Backend Engineering & Functional Programming