การใช้ Kotlin สำหรับการพัฒนาส่วนหลัง: ภาพรวมโดยย่อ

ฉันไม่จำเป็นต้องแนะนำ Kotlin ให้กับนักพัฒนา Android ที่เป็นเจ้าของภาษา เนื่องจากในเดือนพฤษภาคม 2017 Google ประกาศว่ามันจะเป็นภาษาทางการสำหรับการพัฒนา Android ตั้งแต่นั้นมา ก็ได้รับความนิยมอย่างมากในฐานะที่เป็นตัวเลือกภาษาหลักสำหรับการพัฒนาแอป Android ใหม่และเป็นประกาย มันแก้ไขจุดอ่อนของ Java ได้มาก ดังนั้นแอพใหม่ ๆ ส่วนใหญ่จะเขียนอยู่ในนั้นและแอพเก่า ๆ จะถูกเขียนใหม่

ไม่ต้องสงสัยเลยว่ามันเยี่ยมมากที่ส่วนหน้าของแอปพลิเคชัน และเมื่อคุณพูดถึง Kotlin เป็นครั้งแรก คนส่วนใหญ่เชื่อมโยงกับระบบปฏิบัติการ Android อย่างไรก็ตาม ในบทความนี้ ฉันจะพูดถึง Kotlin เป็นภาษาแบ็คเอนด์ และฉันต้องการแบ่งปันเรื่องราวของฉันเกี่ยวกับการสร้างแบ็คเอนด์ Kotlin ที่รวดเร็ว เชื่อถือได้ และไม่ซิงโครนัสสำหรับโปรเจ็กต์งานอดิเรก Android ของฉัน ฉันจะไม่พูดถึงว่าโครงการเกี่ยวกับอะไร เนื่องจากอยู่นอกขอบเขตของบทความนี้ แต่ฉันจะเน้นที่การอธิบายว่าทำไมฉันถึงเลือก Kotlin และทำไมฉันถึงคิดว่ามันเป็นภาษาที่ยอดเยี่ยมสำหรับการเขียนแอปพลิเคชันฝั่งเซิร์ฟเวอร์หรือ REST API

ทำไมต้องคอตลิน?

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

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

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

 public class Person { private final String name; private final int age; public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } }

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

 class Person( val name: String, val age: Int )

มันสั้นและง่ายกว่าแน่นอน ตัวแปรถือเป็นที่สิ้นสุดเมื่อเราใช้คีย์เวิร์ด val ตัวสร้างและตัวรับถูกสร้างขึ้นในเวลารวบรวม หากเราไม่ต้องการมีวัตถุที่ไม่เปลี่ยนรูป เราก็สามารถเปลี่ยน val เป็น var และ voila เรามีบุคคลที่ไม่เปลี่ยนรูป และเราต้องทำเพียงแค่เปลี่ยนตัวอักษรหนึ่งตัว

ส่วนที่สองที่ฉันโปรดปรานในคลาส Java POJO อย่างง่ายคือการแทนที่ equals() และ hashCode() สิ่งเหล่านี้ถูกสร้างขึ้นโดยอัตโนมัติอีกครั้งเกือบตลอดเวลา แต่คุณต้องข้ามไปเพื่อให้แน่ใจว่า ข่าวดีก็คือ Kotlin สามารถจัดการกับสิ่งนี้ได้เช่นกัน เพียงแค่เปลี่ยน class ของคุณเป็น data class แล้วคุณจะได้ equals() และ hashCode() ออกจากกล่อง

 data class Person( val name: String, val age: Int )

กล่าวโดยย่อ ถึงแม้ว่าฉันจะรัก Java แต่ฉันก็ต้องการที่จะสร้างผลิตภัณฑ์ที่ใช้งานได้ขั้นต่ำสำหรับโครงการของฉันโดยเร็วที่สุดเท่าที่จะเป็นไปได้ในเวลาอันสั้น และในกรณีของการพัฒนาซอฟต์แวร์ วิธีที่ง่ายที่สุดในการทำเช่นนี้คือการเขียนโค้ดให้น้อยลง ดังนั้น การค้นหาภาษาที่ดีกว่าสำหรับการพัฒนาแบ็กเอนด์จึงดำเนินต่อไป ด้วยความคิดนี้ ฉันจึงเปลี่ยนไปใช้ Node.js ก่อน มีข้อดีที่สำคัญบางประการ—สองสามบรรทัดและเซิร์ฟเวอร์ Express ของคุณเปิดและทำงาน กำลังฟังบนพอร์ต 8080 และตอบสนองด้วย Hello World! ทุกครั้งที่คุณส่งคำขอรับ

 let express = require('express') let app = express(); app.get('/', (req, res) => res.send('Hello World!')); app.listen(8080);

ง่าย ง่าย และรวดเร็ว สิ่งที่คุณคาดหวังจากภาษาโปรแกรมที่ได้รับความนิยมมากที่สุดภาษาหนึ่ง ฉันสนุกกับการทำงานกับ JavaScript และในช่วงเวลาสั้นๆ ฉันคิดว่าฉันพบเครื่องมือที่เหมาะสมแล้ว แต่แล้วฉันก็ถูกหลอกหลอนด้วยความจริงที่ว่า JavaScript ถูกพิมพ์แบบไดนามิก อย่าเข้าใจฉันผิด ฉันคิดว่าการพิมพ์แบบไดนามิกนั้นยอดเยี่ยมที่ส่วนหน้า แต่จากประสบการณ์ของฉัน การมีแบ็คเอนด์ที่พิมพ์แบบสแตติกช่วยให้คุณมั่นใจมากขึ้นว่าเซิร์ฟเวอร์ของคุณมีโอกาสน้อยที่จะเกิดความผิดพลาดในขณะรันไทม์เนื่องจากประเภทไม่ตรงกัน . และบอกตามตรงว่าเมื่อส่วนหลังของคุณมีผู้ใช้หลายแสนคน คุณไม่ต้องการให้สิ่งนี้เกิดขึ้นจริงๆ อย่างไรก็ตาม Node.js ได้นำเสนอคุณลักษณะที่ยอดเยี่ยมอย่างหนึ่งที่ฉันต้องการเก็บไว้ ซึ่งสามารถเขียนโค้ดและบริการแบบอะซิงโครนัสได้อย่างง่ายดาย

เมื่อคำนึงถึงข้อกำหนดเหล่านี้ ฉันจึงเลือกที่จะเขียนส่วนหลังของ Kotlin Android ใน Kotlin ด้วย

Kotlin: ภาพรวมโดยย่อ

สำหรับผู้ที่ไม่เคยได้ยินเรื่องนี้มาก่อน Kotlin เป็นภาษาโปรแกรมโอเพนซอร์สที่พิมพ์แบบสแตติกซึ่งสนับสนุนการเขียนโปรแกรมเชิงวัตถุและเชิงฟังก์ชัน มีรูปแบบและแนวคิดที่คล้ายคลึงกันเช่น C#, Java หรือ Scala และกำหนดเป้าหมายไปที่ JVM เป็นหลัก แต่ยังมีตัวแปรที่กำหนดเป้าหมาย JavaScript หรือโค้ดเนทีฟ คล้ายกับ Java มากที่ Kotlin/JVM คอมไพล์เป็น Java bytecode ดังนั้นสำหรับวิศวกรส่วนหลังที่มีพื้นหลัง JVM Kotlin จะเข้าใจได้ง่าย

ตามที่ระบุในเพจอย่างเป็นทางการ จุดมุ่งหมายของ Kotlin ไม่ได้แตกต่างไปจากเดิม แต่เป็นการดึงแรงบันดาลใจและแนวทางปฏิบัติที่ดีที่สุดจากการพัฒนาภาษามานานหลายทศวรรษ สามารถใช้กับ Java IDE ใดก็ได้หรือจากบรรทัดคำสั่ง แต่โดยส่วนตัวแล้วฉันชอบและแนะนำให้ใช้กับ IntelliJ ได้รับการดูแลและอัปเกรดอย่างแข็งขันโดยทีมงาน JetBrains และไม่ต้องกังวลกับการซื้อเวอร์ชันที่ต้องชำระเงิน หากคุณเพิ่งเริ่มใช้งาน Kotlin เวอร์ชันชุมชนของ IntelliJ จะตอบสนองทุกความต้องการของคุณ แง่มุมที่สำคัญที่สุดสามประการของ Kotlin ที่ฉันอยากจะชี้ให้เห็นคือ: a) กระชับ (ลดรหัสสำเร็จรูปลงอย่างมาก) b) ปลอดภัย (ประการหนึ่ง มันถูกสร้างขึ้นเพื่อหลีกเลี่ยงข้อยกเว้นตัวชี้ค่าว่าง) และ c ) ทำงานร่วมกันได้ (คุณสามารถใช้ไลบรารีที่มีอยู่สำหรับ JVM, Android หรือเบราว์เซอร์)

Kotlin Coroutines

ทุกคนต้องการมีบริการที่ให้บริการผู้ใช้อย่างรวดเร็ว เพื่อให้เซิร์ฟเวอร์ของคุณมีความจุสูงสุด สิ่งแรกที่คุณสามารถทำได้คือมีแอปพลิเคชันแบบมัลติเธรด Java ค่อนข้างยุ่งยากกับสิ่งนั้น เมื่อคุณเรียนรู้ Java คุณต้องเรียนรู้ก่อนว่าถ้าคุณต้องการแอปพลิเคชันแบบมัลติเธรด คุณควรขยายคลาส Thread หรือใช้อินเทอร์เฟซ Runnable ผู้เริ่มต้นไม่เคยเข้าใจจริงๆ ว่าความแตกต่างคืออะไร (ถ้ามี) แต่เพื่อเพิ่มความสับสน พวกเขายังได้รับคำสั่งให้เริ่มเธรดด้วยเมธอด run เสมอ อย่าใช้เมธอด start หรือเดี๋ยวก่อนมันเป็นวิธีอื่น ๆ ? ท้ายที่สุด ไม่สำคัญหรอก คุณไม่ควรเริ่มเธรดด้วยตนเองอยู่ดี มันแพงเกินไป แทนที่จะใช้พูลเธรด ง่าย ยกเว้นว่ามันไม่ใช่

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

 fun sendRequest(): Int { /* do some heavy work */ return 1; }

ตัวอย่างนี้แสดงฟังก์ชันการบล็อก เธรดที่รันข้อมูลโค้ดนี้จะไม่ทำงานอื่นใดจนกว่าฟังก์ชันจะส่งคืน ซึ่งในกรณีของ API หรือการเรียกฐานข้อมูลอาจใช้เวลาไม่กี่วินาที เราไม่ต้องการบล็อกเธรดของเราจริง ๆ ขณะรอบริการอื่น ดังนั้นเรามาเปลี่ยนฟังก์ชันนี้เป็นฟังก์ชันที่ไม่บล็อกกัน

 suspend fun sendRequest(): Int { /* do some heavy work */ return 1; }

ตัวอย่างนี้แสดงให้เห็นว่าเราสามารถเปลี่ยนวิธีการของเราให้เป็นฟังก์ชันที่ไม่ปิดกั้นซึ่งสามารถระงับได้ ซึ่งหมายความว่าหากเพื่อความง่าย งานหนักคือการเรียกใช้ฟังก์ชัน delay() อย่างง่ายเป็นเวลา 10 วินาที เธรดที่ดำเนินการจะยังคงทำงานอื่นอยู่ในช่วงเวลานั้นและจะกลับมาดำเนินการฟังก์ชันต่อไปหลังจากผ่านไป 10 วินาที โค้ดดีๆ ที่ไม่มีการบล็อกทำได้ด้วยคีย์เวิร์ดเพียงคำเดียว

บริการแบบอะซิงโครนัสกับ Ktor

เมื่อพูดถึงการเขียน REST API มีขั้นตอนพิเศษบางอย่างที่ต้องทำ เช่น การเริ่มเซิร์ฟเวอร์ฝังตัวหรือการแยกวิเคราะห์คำขอ และแน่นอนว่าไม่มีใครอยากทำด้วยตนเอง Java มี Spring Boot ซึ่งทำให้สิ่งต่างๆ เป็นเรื่องง่าย และโชคดีที่ Kotlin มีเฟรมเวิร์กที่เรียกว่า Ktor Ktor เป็นเว็บเฟรมเวิร์กสำหรับสร้างเซิร์ฟเวอร์แบบอะซิงโครนัส ตามที่เว็บไซต์ระบุไว้ Ktor นั้น “ใช้งานง่าย สนุกและไม่พร้อมกัน” ในตอนนี้ ความสนุกเป็นเรื่องเฉพาะบุคคล ดังนั้น ฉันไม่อยากพิสูจน์ว่าอย่างไรก็ตาม มาดูตัวอย่างที่พิสูจน์แล้วว่าใช้งานง่ายและไม่ตรงกัน

 fun main() { embeddedServer(Tomcat, 8080) { routing { get { call.respond("Hello world!") } } }.start(wait = true) }

ตัวอย่างข้างต้นแสดงเซิร์ฟเวอร์ Kotlin Ktor ที่ทำงานได้อย่างสมบูรณ์ซึ่งทำงานบนเซิร์ฟเวอร์ Tomcat แบบฝัง ฟังบนพอร์ต 8080 และจะตอบสนองแบบอะซิงโครนัสด้วย "Hello world!" เพื่อรับคำขอ ทั้งหมดนี้ในโค้ดน้อยกว่า 10 บรรทัด

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

ประโยชน์อื่นๆ ของ Kotlin ที่ส่วนหลัง

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

ข้อได้เปรียบที่สำคัญอีกประการหนึ่งของ Kotlin และ Ktor คือไลบรารีและเฟรมเวิร์กการทดสอบที่ครอบคลุมที่คุณสามารถใช้ได้ กรอบงาน Junit ใช้งานได้อย่างมีเสน่ห์กับ Kotlin และ Ktor ได้เพิ่มไลบรารีการทดสอบของตัวเองที่ช่วยให้คุณเขียนการทดสอบแบบ end-to-end และการทดสอบการรวมในเวลาไม่นาน คุณสามารถใช้เอ็นจิ้นการทดสอบแบบกำหนดเองที่จะเรียกใช้แอปพลิเคชันทั้งหมดของคุณ และสามารถจัดการคำขอได้เช่นเดียวกับแอปพลิเคชันที่ใช้งานจริง

บทสรุป

ดังที่ฉันได้กล่าวไว้ก่อนหน้านี้ ฉันเป็นนักพัฒนาส่วนหลังของ Java เป็นหลักซึ่งมีแอปพลิเคชันฝั่งเซิร์ฟเวอร์หลายตัวและ REST APIs อยู่เบื้องหลัง แม้ว่าฉันจะชอบเขียนโปรแกรมใน Java แต่ฉันคิดว่าไม่มีภาษาหรือเฟรมเวิร์กที่ดีที่สุดเพียงภาษาเดียวที่เหมาะกับงานใดๆ และสามารถแก้ปัญหาใดๆ ได้ แนวทางของฉันคือทำความคุ้นเคยกับเครื่องมือให้มากที่สุดเท่าที่จะทำได้ และเมื่อเกิดปัญหา ให้เลือกเครื่องมือที่ดีที่สุดที่สามารถแก้ปัญหานั้นได้อย่างไม่มีที่ติ

ตามที่เว็บไซต์ Kotlin ระบุไว้ จุดมุ่งหมายของ Kotlin นั้นไม่ได้แตกต่างไปจากเดิม แต่มันดึงแรงบันดาลใจและแนวทางปฏิบัติที่ดีที่สุดจากการพัฒนาภาษามาหลายทศวรรษ และฉันเชื่อว่าเมื่อพูดถึงการพัฒนาแบ็คเอนด์ Kotlin, Coroutines และ Ktor จะสร้างสามคนที่น่าทึ่งในการทำงาน คุณสามารถอ่านเพิ่มเติมเกี่ยวกับ Kotlin และประโยชน์ของมันในฐานะภาษาโปรแกรมได้ที่นี่