ฉันไม่จำเป็นต้องแนะนำ 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 ) มันสั้นและง่ายกว่าแน่นอน ตัวแปรถือเป็นขั้นสุดท้ายเมื่อเราใช้ ชม คำสำคัญ; ตัวสร้างและ getters ถูกสร้างขึ้นในเวลาคอมไพล์ ถ้าเราไม่ต้องการให้มีวัตถุที่ไม่เปลี่ยนรูปเราก็สามารถเปลี่ยนได้ ชม ถึง ที่ไหน และ 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 และตอบสนองด้วย สวัสดีชาวโลก! ทุกครั้งที่คุณส่งคำขอรับ
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 เป็นภาษาการเขียนโปรแกรมแบบโอเพนซอร์สที่พิมพ์แบบคงที่ซึ่งรองรับทั้งการเขียนโปรแกรมเชิงวัตถุและเชิงฟังก์ชัน มีไวยากรณ์และแนวคิดที่คล้ายกันเช่น 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 หรือเบราว์เซอร์)
ใคร ๆ ก็อยากมีบริการที่ให้บริการผู้ใช้ได้อย่างรวดเร็ว เพื่อให้ได้ความจุสูงสุดของเซิร์ฟเวอร์ของคุณสิ่งแรกที่คุณสามารถทำได้คือการมีแอปพลิเคชันมัลติเธรด Java ค่อนข้างยุ่งยากด้วย เมื่อคุณเรียนรู้ Java ก่อนอื่นคุณต้องเรียนรู้ว่าหากคุณต้องการแอปพลิเคชันมัลติเธรดคุณควรขยายคลาสเธรดหรือใช้อินเทอร์เฟซ Runnable ผู้เริ่มต้นไม่เคยเข้าใจจริงๆว่าความแตกต่างคืออะไร (ถ้ามี) แต่เพื่อเพิ่มความสับสนพวกเขายังบอกให้เริ่มเธรดด้วยวิธีการรันเสมออย่าใช้วิธีเริ่มต้น หรือรอมันเป็นวิธีอื่น? ท้ายที่สุดมันก็ไม่สำคัญคุณไม่ควรเริ่มเธรดด้วยตนเองอย่างไรก็ตามมันแพงเกินไปแทนที่จะใช้เธรดพูล เรียบง่ายยกเว้นว่าไม่ใช่
โชคดีที่ Kotlin มีวิธีแก้ปัญหาที่ง่ายกว่าที่เรียกว่า coroutines พูดง่ายๆคือโครูทีนช่วยให้สามารถเขียนโค้ดแบบอะซิงโครนัสและไม่ปิดกั้นได้อย่างคล่องแคล่ว แนวคิดหลักคือการมีฟังก์ชันที่สามารถระงับได้ กล่าวอีกนัยหนึ่งก็คือการคำนวณอาจถูกระงับในบางจุดและดำเนินการต่อในภายหลัง ส่วนที่ดีที่สุดคือเมื่อเขียนโค้ดที่ไม่ปิดกั้นรูปแบบการเขียนโปรแกรมจะไม่เปลี่ยนแปลงจริงๆดังนั้นการเขียนโค้ดแบบไม่ปิดกั้นจึงเหมือนกับการเขียนโค้ดบล็อก ลองดูสองตัวอย่าง:
fun sendRequest(): Int { /* do some heavy work */ return 1; } ตัวอย่างนี้แสดงฟังก์ชันการบล็อก เธรดที่เรียกใช้ข้อมูลโค้ดนี้จะไม่ทำงานอื่นใดจนกว่าฟังก์ชันจะกลับมาซึ่งในกรณีของการเรียก API หรือฐานข้อมูลอาจใช้เวลาสองถึงสามวินาที เราไม่ต้องการบล็อกชุดข้อความของเราในขณะที่รอบริการอื่นดังนั้นเรามาเปลี่ยนฟังก์ชันนี้ให้เป็นฟังก์ชันที่ไม่ปิดกั้น
suspend fun sendRequest(): Int { /* do some heavy work */ return 1; } ตัวอย่างนี้แสดงให้เห็นว่าเราสามารถเปลี่ยนวิธีการของเราให้เป็นฟังก์ชันที่ไม่ปิดกั้นซึ่งสามารถระงับได้อย่างไร ซึ่งหมายความว่าถ้าเพื่อความเรียบง่ายงานหนักก็คือ delay() การเรียกใช้ฟังก์ชันของ 10 วินาทีเธรดที่ดำเนินการจะยังคงทำงานในงานอื่น ๆ ในช่วงเวลานั้นและจะกลับมาทำงานของฟังก์ชันต่อไปหลังจากผ่านไป 10 วินาที รหัสที่ดีและไม่ปิดกั้นสามารถทำได้ด้วยคำหลักเดียว
เมื่อพูดถึงการเขียน 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 สามารถทำได้ในฝั่งเซิร์ฟเวอร์และวิธีกำหนดค่า ที่นี่ .
อะไรทำให้เกิดวิกฤตหนี้กรีก
ประโยชน์ประการแรกที่ฉันอยากจะชี้ให้เห็นคือคุณสามารถใช้ไลบรารี Java ใน Kotlin และเชื่อฉันเถอะว่ามีไลบรารีของบุคคลที่สามที่น่าทึ่งมากมายสำหรับ Java ที่สามารถทำให้ชีวิตของคุณง่ายขึ้น ทำไมคุณต้องเขียนการใช้งานของคุณเองในเมื่อมีไลบรารีโอเพนซอร์สพร้อมใช้งานที่ทำงานได้อย่างสมบูรณ์แบบ การใช้สิ่งเหล่านี้กับ Kotlin ทำงานได้อย่างไม่มีที่ติ
ข้อดีที่สำคัญอีกอย่างของ Kotlin และ Ktor คือไลบรารีและเฟรมเวิร์กการทดสอบที่ครอบคลุมที่คุณสามารถใช้ได้ เฟรมเวิร์ก Junit ทำงานได้อย่างมีเสน่ห์กับ Kotlin และ Ktor เพิ่มไลบรารีการทดสอบของตัวเองที่ช่วยให้คุณเขียนการทดสอบแบบ end-to-end และการทดสอบการรวมได้ในเวลาอันรวดเร็ว คุณสามารถใช้เครื่องมือทดสอบที่กำหนดเองซึ่งจะเรียกใช้แอปพลิเคชันทั้งหมดของคุณและสามารถจัดการคำขอได้เช่นเดียวกับแอปพลิเคชันจริง
ดังที่ได้กล่าวไว้ก่อนหน้านี้ฉันเป็นนักพัฒนาส่วนหลังของ Java ที่มีแอปพลิเคชันฝั่งเซิร์ฟเวอร์และ REST API หลายตัวอยู่ข้างหลังฉัน แม้ว่าฉันจะชอบการเขียนโปรแกรมใน Java แต่ฉันคิดว่าไม่มีภาษาหรือเฟรมเวิร์กที่ดีที่สุดเพียงภาษาเดียวที่เหมาะกับงานใด ๆ และสามารถแก้ปัญหาได้ แนวทางของฉันคือทำความคุ้นเคยกับเครื่องมือให้มากที่สุดเท่าที่จะทำได้และเมื่อเกิดปัญหาขึ้นให้เลือกเครื่องมือที่ดีที่สุดที่สามารถแก้ปัญหานั้นได้อย่างไม่มีที่ติ
ในฐานะที่เป็นเว็บไซต์ Kotlin ระบุว่าจุดมุ่งหมายของ Kotlin ไม่ได้มีความโดดเด่น แทนที่จะดึงแรงบันดาลใจและแนวทางปฏิบัติที่ดีที่สุดจากการพัฒนาภาษามานานหลายทศวรรษและฉันเชื่อว่าเมื่อพูดถึงการพัฒนาแบบแบ็คเอนด์ Kotlin, Coroutines และ Ktor จะสร้างสามคนที่น่าทึ่งเพื่อทำงานนี้ คุณสามารถอ่านเพิ่มเติมเกี่ยวกับ Kotlin และประโยชน์ของมันในฐานะภาษาโปรแกรม ที่นี่ .
ใช่. โครูทีนคือเธรดที่ทำงานแบบอะซิงโครนัสและถูกระงับหากจำเป็นจากนั้นรีสตาร์ทในภายหลัง สามารถใช้เพื่อให้ได้ประสิทธิภาพระดับสูงที่ส่วนหลัง
แม้ว่าจะมีภาษาการเขียนโปรแกรมเพียงไม่กี่ภาษาที่สามารถจัดประเภทเป็นส่วนหน้าหรือส่วนหลังอย่างเคร่งครัด Kotlin มีลักษณะเช่นการพิมพ์แบบคงที่ซึ่งทำให้ง่ายต่อการใช้งานสำหรับการเขียนโปรแกรมส่วนหลัง
ด้วยคุณสมบัติประสิทธิภาพสูงเช่นโครูทีนและความสามารถในการใช้ไลบรารี Java ทำให้ Kotlin เป็นภาษาที่ยอดเยี่ยมสำหรับการพัฒนาส่วนหลัง
ใช่. Coroutines คือเธรดที่รันได้และถูกระงับชั่วคราว ช่วยให้แอปพลิเคชันจัดการกิจกรรมของผู้ใช้หลายคนพร้อมกัน
