ทำความเข้าใจและใช้งาน REST API

มีโอกาสสูงที่คุณจะเจอคำว่า “REST API” หากคุณเคยคิดที่จะรับข้อมูลจากแหล่งอื่นบนอินเทอร์เน็ต เช่น Twitter หรือ Github แต่ REST API คืออะไร? มันทำอะไรให้คุณได้บ้าง? คุณใช้มันอย่างไร?

ในบทความนี้ คุณจะได้เรียนรู้ทุกสิ่งที่คุณจำเป็นต้องรู้เกี่ยวกับ REST API เพื่อให้สามารถอ่านเอกสาร API และใช้งานได้อย่างมีประสิทธิภาพ

REST API คืออะไร

สมมติว่าคุณกำลังพยายามค้นหาวิดีโอเกี่ยวกับแบทแมนใน Youtube คุณเปิด Youtube พิมพ์ "แบทแมน" ในช่องค้นหา กด Enter และคุณจะเห็นรายการวิดีโอเกี่ยวกับแบทแมน REST API ทำงานในลักษณะเดียวกัน คุณค้นหาบางสิ่ง และคุณจะได้รับรายการผลลัพธ์กลับมาจากบริการที่คุณร้องขอ

API คืออินเทอร์เฟซการเขียนโปรแกรมแอปพลิเคชัน เป็นชุดของกฎที่อนุญาตให้โปรแกรมสามารถพูดคุยกันได้ ผู้พัฒนาสร้าง API บนเซิร์ฟเวอร์และอนุญาตให้ลูกค้าพูดคุยกับมัน

REST กำหนดลักษณะของ API ย่อมาจาก "การโอนสถานะตัวแทน" เป็นชุดของกฎที่นักพัฒนาปฏิบัติตามเมื่อสร้าง API กฎข้อใดข้อหนึ่งระบุว่าคุณควรจะได้รับข้อมูลบางส่วน (เรียกว่าทรัพยากร) เมื่อคุณลิงก์ไปยัง URL เฉพาะ

แต่ละ URL เรียกว่า คำขอ ในขณะที่ข้อมูลที่ส่งกลับมาถึงคุณเรียกว่าการ ตอบกลับ

กายวิภาคของคำขอ

สิ่งสำคัญคือต้องรู้ว่าคำขอประกอบด้วยสี่สิ่ง:

1. จุดสิ้นสุด
2. วิธีการ
3. ส่วนหัว
4. ข้อมูล (หรือเนื้อหา)

จุดสิ้นสุด (หรือเส้นทาง) คือ URL ที่คุณร้องขอ มันเป็นไปตามโครงสร้างนี้:

 root-endpoint/ ? root-endpoint/ ? root-endpoint/ ?

root-endpoint คือจุดเริ่มต้นของ API ที่คุณร้องขอ จุดปลายรากของ API ของ Github คือ https://api.github.com ในขณะที่ API ของปลายทางของ Twitter คือ https://api.twitter.com

เส้นทาง จะกำหนดทรัพยากรที่คุณร้องขอ ให้คิดเหมือนเครื่องตอบรับอัตโนมัติที่ขอให้คุณกด 1 บริการ กด 2 สำหรับบริการอื่น กด 3 สำหรับบริการอื่น เป็นต้น

คุณสามารถเข้าถึงเส้นทางได้เหมือนกับที่คุณลิงก์ไปยังส่วนต่างๆ ของเว็บไซต์ ตัวอย่างเช่น หากต้องการดูรายการโพสต์ทั้งหมดที่ติดแท็กภายใต้ “JavaScript” ใน Smashing Magazine ให้ไปที่ https://www.smashingmagazine.com/tag/javascript/ https://www.smashingmagazine.com/ คือ root-endpoint และ /tag/javascript คือเส้นทาง

เพื่อให้เข้าใจว่าคุณมีเส้นทางใดบ้าง คุณต้องดูเอกสาร API ตัวอย่างเช่น สมมติว่าคุณต้องการรับรายการที่เก็บโดยผู้ใช้บางรายผ่าน API ของ Github เอกสารบอกให้คุณใช้เส้นทางต่อไปนี้:

 /users/:username/repos

โคลอนใดๆ ( : ) บนพาธแสดงถึงตัวแปร คุณควรแทนที่ค่าเหล่านี้ด้วยค่าจริงของเวลาที่คุณส่งคำขอ ในกรณีนี้ คุณควรแทนที่ :username ด้วยชื่อผู้ใช้จริงของผู้ใช้ที่คุณกำลังค้นหา หากฉันกำลังค้นหาบัญชี Github ฉันจะแทนที่ :username ด้วย zellwk

ปลายทางเพื่อรับรายการ repos ของฉันบน Github คือ:

 https://api.github.com/users/zellwk/repos

ส่วนสุดท้ายของปลายทางคือ พารามิเตอร์การค้นหา ในทางเทคนิค พารามิเตอร์การค้นหาไม่ได้เป็นส่วนหนึ่งของสถาปัตยกรรม REST แต่คุณจะเห็นว่า API จำนวนมากใช้พารามิเตอร์เหล่านี้ ดังนั้น เพื่อช่วยให้คุณเข้าใจวิธีการอ่านและใช้งาน API อย่างสมบูรณ์ เราจะพูดถึงเรื่องนี้ด้วย พารามิเตอร์การค้นหาให้ตัวเลือกแก่คุณในการแก้ไขคำขอของคุณด้วยคู่คีย์-ค่า มักเริ่มต้นด้วยเครื่องหมายคำถาม ( ? ) จากนั้นคู่พารามิเตอร์แต่ละคู่จะถูกคั่นด้วยเครื่องหมายและ ( & ) ดังนี้:

 ?query1=value1&query2=value2

เมื่อคุณพยายามรับรายการที่เก็บของผู้ใช้บน Github คุณต้องเพิ่มพารามิเตอร์ที่เป็นไปได้สามตัวในคำขอของคุณเพื่อแก้ไขผลลัพธ์ที่มอบให้คุณ:

หากคุณต้องการรับรายการที่เก็บที่ฉันพุชไปเมื่อเร็วๆ นี้ คุณสามารถตั้งค่า sort to push

 https://api.github.com/users/zellwk/repos?sort=pushed

คุณจะทราบได้อย่างไรว่าจุดสิ้นสุดนี้ใช้งานได้ ถึงเวลาแล้วที่จะลองดูสิ!

การทดสอบจุดปลายด้วย curl

คุณสามารถส่งคำขอด้วยภาษาการเขียนโปรแกรมใดก็ได้ ผู้ใช้ JavaScript สามารถใช้วิธีการต่างๆ เช่น Fetch API และวิธี Ajax ของ jQuery ผู้ใช้ Ruby สามารถใช้คลาส Ruby's Net::HTTP, ผู้ใช้ Python สามารถใช้ Python Requests; และอื่นๆ

สำหรับบทความนี้ เราจะใช้ยูทิลิตีบรรทัดคำสั่งที่เรียกว่า cURL เราใช้ cURL เนื่องจากเอกสาร API มักจะเขียนโดยอ้างอิงถึง cURL หากคุณเข้าใจวิธีใช้ cURL คุณจะไม่มีปัญหาในการทำความเข้าใจเอกสาร API จากนั้น คุณสามารถดำเนินการตามคำขอได้อย่างง่ายดายด้วยภาษาที่คุณต้องการ

ก่อนที่คุณจะดำเนินการต่อ คุณจะต้องแน่ใจว่าได้ติดตั้ง cURL ไว้ในเครื่องของคุณแล้ว เปิด Terminal ของคุณและพิมพ์ curl -version คำสั่งนี้จะตรวจสอบเวอร์ชันของ cURL ที่คุณติดตั้งไว้ในระบบของคุณ

 curl --version

หากคุณไม่ได้ติดตั้ง cURL ไว้ คุณจะได้รับข้อผิดพลาด "ไม่พบคำสั่ง" หากคุณได้รับข้อผิดพลาดนี้ คุณจะต้องติดตั้ง curl ก่อนดำเนินการต่อ

หากต้องการใช้ cURL ให้พิมพ์ curl ตามด้วยปลายทางที่คุณต้องการ ตัวอย่างเช่น ในการรับจุดปลายรากของ Github คุณพิมพ์ดังต่อไปนี้:

 curl https://api.github.com

เมื่อคุณกด Enter คุณควรได้รับการตอบกลับจาก Github ที่มีลักษณะดังนี้:

ในการรับรายการที่เก็บของผู้ใช้ คุณต้องแก้ไขปลายทางให้เป็นพาธที่ถูกต้อง เช่นเดียวกับที่เรากล่าวถึงข้างต้น ในการรับรายการที่เก็บของฉัน คุณสามารถใช้คำสั่งนี้:

 curl https://api.github.com/users/zellwk/repos

หากคุณต้องการรวมพารามิเตอร์การค้นหาด้วย cURL ตรวจสอบให้แน่ใจว่าคุณได้ใส่เครื่องหมายแบ็กสแลช ( \ ) นำหน้า ? และ = ตัวอักษร เป็นเพราะ ? และ = เป็นอักขระพิเศษในบรรทัดคำสั่ง คุณต้องใช้ \ ก่อนหน้านั้นเพื่อให้บรรทัดคำสั่งตีความว่าเป็นอักขระปกติ:

 curl https://api.github.com/users/zellwk/repos\?sort\=pushed

ลองใช้คำสั่งใดคำสั่งหนึ่งและดำเนินการตามคำขอ! คุณจะได้รับการตอบสนองที่คล้ายคลึงกันกับสิ่งที่คุณเคยเห็นด้วย root-endpont ของ Github (แต่มีข้อมูลมากขึ้น)

JSON

JSON (JavaScript Object Notation) เป็นรูปแบบทั่วไปสำหรับการส่งและขอข้อมูลผ่าน REST API การตอบกลับที่ Github ส่งกลับมายังถูกจัดรูปแบบเป็น JSON ด้วย

วัตถุ JSON ดูเหมือนวัตถุ JavaScript ใน JSON แต่ละพร็อพเพอร์ตี้และค่าต้องหุ้มด้วยเครื่องหมายอัญประกาศคู่ ดังนี้:

 { "property1": "value1", "property2": "value2", "property3": "value3" }

กลับไปที่กายวิภาคของคำขอ

คุณได้เรียนรู้ว่าคำขอประกอบด้วยสี่ส่วน

1. จุดสิ้นสุด
2. วิธีการ
3. ส่วนหัว
4. ข้อมูล (หรือเนื้อหา)

มาดูส่วนที่เหลือของคำขอกัน

วิธีการ

วิธีการคือประเภทของคำขอที่คุณส่งไปยังเซิร์ฟเวอร์ คุณสามารถเลือกจากห้าประเภทนี้ด้านล่าง:

• GET
• POST
• PUT
• PATCH
• DELETE

วิธีการเหล่านี้มีความหมายสำหรับคำขอของคุณ ใช้เพื่อดำเนินการสี่อย่างที่เป็นไปได้: Create Read Update และ Delete (CRUD)

API ช่วยให้คุณทราบวิธีคำขอที่จะใช้แต่ละคำขอ ตัวอย่างเช่น หากต้องการรับรายการที่เก็บของผู้ใช้ คุณต้องมีคำขอ GET :

ต้องมีคำขอ GET เพื่อรับรายการที่เก็บจากผู้ใช้ ในการสร้างที่เก็บ Github ใหม่ คุณต้องมีคำขอ POST :

คุณสามารถตั้งค่าวิธีการขอใน cURL โดยเขียน -X หรือ --request ตามด้วยวิธีการขอ คำสั่งด้านล่างนี้พยายามสร้างที่เก็บผ่าน cURL:

 curl -X POST https://api.github.com/user/repos

ลองเรียกใช้คำขอนี้ คุณจะได้รับคำตอบที่แจ้งว่าจำเป็นต้องมีการตรวจสอบสิทธิ์ (เพิ่มเติมเกี่ยวกับการรับรองความถูกต้องในภายหลัง)

 { "message": "Requires authentication", "documentation_url": "https://developer.github.com/v3" }

ส่วนหัว

ส่วนหัวใช้เพื่อให้ข้อมูลกับทั้งไคลเอ็นต์และเซิร์ฟเวอร์ สามารถใช้เพื่อวัตถุประสงค์หลายอย่าง เช่น การรับรองความถูกต้องและการให้ข้อมูลเกี่ยวกับเนื้อหาในร่างกาย คุณสามารถค้นหารายการส่วนหัวที่ถูกต้องได้จากข้อมูลอ้างอิงส่วนหัว HTTP ของ MDN

ส่วนหัว HTTP เป็นคู่ของค่าคุณสมบัติ ที่คั่นด้วยเครื่องหมายทวิภาค ตัวอย่างด้านล่างแสดงส่วนหัวที่บอกให้เซิร์ฟเวอร์คาดหวังเนื้อหา JSON

 "Content-Type: application/json". Missing the opening ".

คุณสามารถส่งส่วนหัว HTTP ด้วย curl ผ่านตัวเลือก -H หรือ --header ในการส่งส่วนหัวข้างต้นไปยัง API ของ Github คุณใช้คำสั่งนี้:

 curl -H "Content-Type: application/json" https://api.github.com

(หมายเหตุ: ส่วนหัว Content-Type ไม่ใช่ข้อกำหนดสำหรับ API ของ Github ในการทำงาน นี่เป็นเพียงตัวอย่างเพื่อแสดงวิธีใช้ส่วนหัวกับ cURL)

หากต้องการดูส่วนหัวที่คุณส่ง คุณสามารถใช้ตัวเลือก -v หรือ --verbose เมื่อคุณส่งคำขอ ดังนี้:

 curl -H "Content-Type: application/json" https://api.github.com -v 

ในที่นี้ * หมายถึงข้อมูลเพิ่มเติมจาก cURL > หมายถึงส่วนหัวของคำขอ และ < หมายถึงส่วนหัวของการตอบกลับ

ข้อมูล (หรือ “ร่างกาย”)

ข้อมูล (บางครั้งเรียกว่า "เนื้อหา" หรือ "ข้อความ") มีข้อมูลที่คุณต้องการส่งไปยังเซิร์ฟเวอร์ ตัวเลือกนี้ใช้กับ POST , PUT , PATCH หรือ DELETE เท่านั้น

ในการส่งข้อมูลผ่าน cURL คุณสามารถใช้ตัวเลือก -d หรือ --data :

 curl -X POST <URL> -d property1=value1

หากต้องการส่งช่องข้อมูลหลายช่อง คุณสามารถสร้างตัวเลือก -d ได้หลายช่อง:

 curl -X POST <URL> -d property1=value1 -d property2=value2

ถ้ามันสมเหตุสมผล คุณสามารถแบ่งคำขอของคุณออกเป็นหลายบรรทัด \ เพื่อให้อ่านง่ายขึ้น:

 curl -X POST <URL> \ -d property1=value1 \ -d property2=value2

หากคุณรู้วิธีสร้างเซิร์ฟเวอร์ คุณสามารถสร้าง API และทดสอบข้อมูลของคุณเองได้ หากคุณไม่รู้ แต่กล้าที่จะลอง คุณสามารถทำตามบทความนี้เพื่อเรียนรู้การสร้างเซิร์ฟเวอร์ด้วย Node, Express และ MongoDB

หากคุณไม่ต้องการเปิดเซิร์ฟเวอร์ของคุณ คุณสามารถไปที่ Requestbin.com ( ฟรี! ) และคลิกที่ “สร้างจุดสิ้นสุด” คุณจะได้รับ URL ที่คุณสามารถใช้ทดสอบคำขอ เช่น https://requestb.in/1ix963n1 ที่แสดงในภาพด้านล่าง

ตรวจสอบให้แน่ใจว่าคุณได้สร้างถังคำขอของคุณเอง หากคุณต้องการทดสอบคำขอของคุณ ถังคำขอจะยังคงเปิดอยู่เป็นเวลา 48 ชั่วโมงหลังจากสร้าง เมื่อคุณอ่านบทความนี้ ถังขยะที่ฉันสร้างไว้ด้านบนจะหายไปนานแล้ว

ตอนนี้ ลองส่งข้อมูลไปที่ถังคำขอของคุณ จากนั้นรีเฟรชหน้าเว็บของถังขยะ คุณจะเห็นข้อมูลบางอย่างเช่นนี้

 curl -X POST https://requestb.in/1ix963n1 \ -d property1=value1 \ -d property2=value2 

ตามค่าเริ่มต้น cURL จะส่งข้อมูลราวกับว่าพวกเขาถูกส่งผ่าน "ช่องแบบฟอร์ม" บนหน้า หากคุณต้องการส่งข้อมูล JSON คุณจะต้องตั้งค่า Content-Type เป็น application/json และคุณจะต้องจัดรูปแบบข้อมูลของคุณเป็นวัตถุ JSON ดังนี้:

 curl -X POST https://requestb.in/1ix963n1 \ -H "Content-Type: application/json" \ -d '{ "property1":"value1", "property2":"value2" }' 

และนั่นคือ (เกือบ!) ทุกสิ่งที่คุณจำเป็นต้องรู้เกี่ยวกับโครงสร้างของคำขอ

จำได้ไหมว่าเมื่อคุณพยายามส่งคำขอ POST ผ่าน Github API คุณได้รับข้อความว่า "ต้องมีการตรวจสอบสิทธิ์" นั่นเป็นเพราะคุณไม่ได้รับอนุญาตให้ดำเนินการตามคำขอ POST !

การตรวจสอบสิทธิ์

คุณจะไม่อนุญาตให้ใครเข้าถึงบัญชีธนาคารของคุณโดยไม่ได้รับอนุญาตใช่ไหม ในแนวความคิดเดียวกัน นักพัฒนาซอฟต์แวร์วางมาตรการเพื่อให้แน่ใจว่าคุณดำเนินการเมื่อคุณได้รับอนุญาตให้ทำเท่านั้น ซึ่งจะป้องกันไม่ให้ผู้อื่นแอบอ้างเป็นคุณ

เนื่องจาก POST , PUT , PATCH และ DELETE เปลี่ยนแปลงฐานข้อมูล นักพัฒนาจึงมักจะวางไว้หลังกำแพงการตรวจสอบสิทธิ์ ในบางกรณี คำขอ GET ต้องมีการตรวจสอบสิทธิ์ด้วย (เช่น เมื่อคุณเข้าถึงบัญชีธนาคารของคุณเพื่อตรวจสอบยอดเงินปัจจุบันของคุณ เป็นต้น)

บนเว็บ มีสองวิธีหลักในการตรวจสอบตัวเอง:

1. ด้วยชื่อผู้ใช้และรหัสผ่าน (เรียกอีกอย่างว่าการตรวจสอบขั้นพื้นฐาน)
2. ด้วยสัญลักษณ์ลับ

วิธีโทเค็นลับรวมถึง oAuth ซึ่งช่วยให้คุณตรวจสอบตัวเองกับเครือข่ายโซเชียลมีเดียเช่น Github, Google, Twitter, Facebook เป็นต้น

สำหรับบทความนี้ คุณจะได้เรียนรู้การใช้การรับรองความถูกต้องขั้นพื้นฐานด้วยชื่อผู้ใช้และรหัสผ่านเท่านั้น หากคุณสนใจที่จะตรวจสอบสิทธิ์ด้วย oAuth ฉันขอแนะนำให้อ่าน “สิ่งที่คุณต้องรู้เกี่ยวกับ OAuth2 และการเข้าสู่ระบบด้วย Facebook” โดย Zack Grossbart

ในการดำเนินการตรวจสอบสิทธิ์พื้นฐานด้วย cURL คุณสามารถใช้ตัวเลือก -u ตามด้วยชื่อผู้ใช้และรหัสผ่านของคุณ ดังนี้:

 curl -x POST -u "username:password" https://api.github.com/user/repos

ลองตรวจสอบตัวเองด้วยชื่อผู้ใช้และรหัสผ่านของคุณในคำขอข้างต้น เมื่อคุณตรวจสอบสิทธิ์สำเร็จแล้ว คุณจะเห็นการตอบกลับเปลี่ยนจาก "ต้องมีการตรวจสอบสิทธิ์" เป็น "ปัญหาในการแยกวิเคราะห์ JSON"

เนื่องจากคุณยังไม่ได้ให้ข้อมูลใดๆ (ซึ่งจำเป็นสำหรับ POST , PUT , PATCH และ DELETE ทั้งหมด) ไปยังเซิร์ฟเวอร์

ด้วยความรู้ที่คุณได้เรียนรู้มา คุณควรจะสามารถแก้ไขโค้ดด้านบนเพื่อสร้างที่เก็บ Github ผ่าน cURL ของคุณได้ ฉันจะปล่อยให้คุณลองด้วยตัวเอง!

ตอนนี้ เรามาพูดถึงรหัสสถานะ HTTP และข้อความแสดงข้อผิดพลาดกัน

รหัสสถานะ HTTP และข้อความแสดงข้อผิดพลาด

ข้อความบางส่วนที่คุณได้รับก่อนหน้านี้ เช่น “ต้องมีการตรวจสอบสิทธิ์” และ “ปัญหาในการแยกวิเคราะห์ JSON” เป็นข้อความแสดงข้อผิดพลาด จะปรากฏเฉพาะเมื่อมีบางอย่างผิดปกติกับคำขอของคุณ รหัสสถานะ HTTP ช่วยให้คุณบอกสถานะของการตอบกลับได้อย่างรวดเร็ว ช่วงตั้งแต่ 100+ ถึง 500+ โดยทั่วไป ตัวเลขจะเป็นไปตามกฎต่อไปนี้:

1. 200+ หมายถึงคำขอ สำเร็จ แล้ว
2. 300+ หมายถึงคำขอถูก เปลี่ยนเส้นทาง ไปยัง URL อื่น
3. 400+ หมายถึงเกิด ข้อผิดพลาดที่มาจากไคลเอนต์ ได้เกิดขึ้น
4. 500+ หมายถึงเกิด ข้อผิดพลาดที่มาจากเซิร์ฟเวอร์ ได้เกิดขึ้น

คุณสามารถดีบักสถานะของการตอบสนองด้วยตัวเลือก verbose ( -v หรือ --verbose ) หรือตัวเลือก head ( -I หรือ --head )

ตัวอย่างเช่น หากคุณพยายามเพิ่ม -I ในคำขอ POST โดยไม่ได้ระบุชื่อผู้ใช้และรหัสผ่าน คุณจะได้รับรหัสสถานะ 401 (ไม่ได้รับอนุญาต):

หากคำขอของคุณไม่ถูกต้องเนื่องจากข้อมูลของคุณไม่ถูกต้องหรือขาดหายไป โดยปกติคุณจะได้รับรหัสสถานะ 400 (คำขอไม่ถูกต้อง)

หากต้องการข้อมูลเพิ่มเติมเกี่ยวกับรหัสสถานะ HTTP ที่เจาะจง คุณอาจต้องศึกษาข้อมูลอ้างอิงสถานะ HTTP ของ MDN

เวอร์ชัน API

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

คุณสามารถขอเวอร์ชัน API เฉพาะได้สองวิธี วิธีที่คุณเลือกขึ้นอยู่กับวิธีเขียน API

สองวิธีนี้คือ:

1. ตรงจุดสิ้นสุด
2. ในส่วนหัวคำขอ

ตัวอย่างเช่น Twitter ใช้วิธีแรก ในขณะที่เขียน API ของ Twitter อยู่ที่เวอร์ชัน 1.1 ซึ่งเห็นได้จากปลายทาง:

 https://api.twitter.com/1.1/account/settings.json

Github ใช้วิธีที่สอง ในขณะที่เขียน API ของ Github อยู่ที่เวอร์ชัน 3 และคุณสามารถระบุเวอร์ชันด้วยส่วนหัว Accept :

 curl https://api.github.com -H Accept:application/vnd.github.v3+json

ห่อ

ในบทความนี้ คุณได้เรียนรู้ว่า REST API คืออะไรและวิธีใช้ cURL เพื่อดำเนินการตามคำขอด้วย GET , POST , PUT , PATCH และ DELETE นอกจากนี้ คุณยังได้เรียนรู้วิธีตรวจสอบคำขอของคุณด้วยตัวเลือก -u และความหมายของสถานะ HTTP

ฉันหวังว่าบทความนี้จะช่วยให้คุณเรียนรู้เกี่ยวกับ REST API ได้เพียงพอ และคุณสามารถใช้มันได้อย่างคล่องแคล่วเมื่อคุณสร้างแอปพลิเคชันของคุณ อย่าลังเลที่จะไปที่บล็อกของฉันหรือแสดงความคิดเห็นของคุณด้านล่างหากคุณมีคำถามใด ๆ