ใช้ Kotlin สำหรับทีมขนาดใหญ่

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

การสร้างทีม

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

กลุ่มแบบฟอร์มศึกษา

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

สร้างวัฒนธรรมการสอน

แม้จะไม่ใช่ทุกคนที่คิดว่าตัวเองเป็นครู แต่ทุกคนก็สอนได้ ไม่ว่าจะเป็นผู้นำฝ่ายเทคโนโลยีหรือทีม ไปจนถึงผู้ร่วมให้ข้อมูลแต่ละคน ทั้ง 2 ฝ่ายสามารถ ส่งเสริมสภาพแวดล้อมการเรียนรู้ที่ช่วยให้ประสบความสำเร็จ วิธีเดียวในการ อำนวยความสะดวกด้วยการจัดให้มีการนำเสนอเป็นระยะๆ โดยที่สมาชิก 1 คนในทีม จะถูกกำหนดให้พูดคุยถึงสิ่งที่พวกเขาได้เรียนรู้หรือต้องการแบ่งปัน คุณสามารถ ใช้ประโยชน์จากกลุ่มการศึกษาของคุณด้วยการขอให้อาสาสมัครนำเสนอบทเรียนใหม่ๆ สัปดาห์จนกว่าคุณจะไปถึงจุดที่ทีมรู้สึกสบายใจกับ ภาษา

แต่งตั้งแชมป์

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

ผสานรวมช้าๆ

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

โมเดลข้อมูล

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

ตัวอย่างเช่น สมมติข้อมูลโค้ดต่อไปนี้ของ Java

public class Person {

   private String firstName;
   private String lastName;
   // ...

   public String getFirstName() {
       return firstName;
   }

   public void setFirstName(String firstName) {
       this.firstName = firstName;
   }

   public String getLastName() {
       return lastName;
   }

   public void setLastName(String lastName) {
       this.lastName = lastName;
   }

   @Override
   public boolean equals(Object o) {
       if (this == o) return true;
       if (o == null || getClass() != o.getClass()) return false;
       Person person = (Person) o;
       return Objects.equals(firstName, person.firstName) &&
               Objects.equals(lastName, person.lastName);
   }

   @Override
   public int hashCode() {
       return Objects.hash(firstName, lastName);
   }

   @Override
   public String toString() {
       return "Person{" +
               "firstName='" + firstName + '\'' +
               ", lastName='" + lastName + '\'' +
               '}';
   }
}

คุณแทนที่คลาส Java ด้วย Kotlin บรรทัดเดียวได้ดังที่แสดงด้านล่างนี้

data class Person(var firstName: String?, var lastName : String?)

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

ย้ายข้อมูลการทดสอบ

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

ย้ายวิธียูทิลิตีไปยังฟังก์ชันส่วนขยาย

คลาสยูทิลิตีแบบคงที่ทั้งหมด (StringUtils, IntegerUtils, DateUtils, YourCustomTypeUtils และอื่นๆ) อาจแสดงเป็น ฟังก์ชันของส่วนขยาย Kotlin และใช้โดย Java Codebase ที่มีอยู่ของคุณ

ตัวอย่างเช่น สมมติว่าคุณมีชั้นเรียน StringUtils ที่มีเมธอด 2-3 วิธีต่อไปนี้

package com.java.project;

public class StringUtils {

   public static String foo(String receiver) {
       return receiver...;  // Transform the receiver in some way
   }

   public static String bar(String receiver) {
       return receiver...;  // Transform the receiver in some way
   }

}

จากนั้น อาจมีการใช้วิธีการเหล่านี้ในที่อื่นๆ ในแอปของคุณ ดังที่แสดงใน ตัวอย่างต่อไปนี้

...

String myString = ...
String fooString = StringUtils.foo(myString);

...

เมื่อใช้ฟังก์ชันส่วนขยาย Kotlin คุณจะระบุอินเทอร์เฟซ Utils เดียวกันให้กับ ผู้เรียกใช้ Java ขณะเดียวกันก็นำเสนอ API ที่กระชับยิ่งขึ้นสำหรับ คือการขยายฐานของโค้ด Kotlin

ในการดำเนินการนี้ ให้เริ่มด้วยการแปลงคลาส Utils นี้เป็น Kotlin โดยใช้ การแปลงอัตโนมัติจาก IDE ตัวอย่างเอาต์พุตอาจมีลักษณะคล้ายกับ ดังต่อไปนี้

package com.java.project

object StringUtils {

   fun foo(receiver: String): String {
       return receiver...;  // Transform the receiver in some way
   }

   fun bar(receiver: String): String {
       return receiver...;  // Transform the receiver in some way
   }

}

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

package com.java.project

fun String.foo(): String {
    return this...;  // Transform the receiver in some way
}

fun String.bar(): String {
    return this...;  // Transform the receiver in some way
}

สุดท้าย ให้เพิ่มคำอธิบายประกอบ JvmName ไว้ที่ด้านบนสุดของไฟล์ต้นฉบับเพื่อทำให้ ชื่อที่คอมไพล์แล้วใช้ได้กับส่วนอื่นๆ ของแอป ดังที่แสดงใน ตัวอย่าง:

@file:JvmName("StringUtils")
package com.java.project
...

เวอร์ชันสุดท้ายควรมีลักษณะคล้ายกับตัวอย่างต่อไปนี้

@file:JvmName("StringUtils")
package com.java.project

fun String.foo(): String {
    return this...;  // Transform `this` string in some way
}

fun String.bar(): String {
    return this...;  // Transform `this` string in some way
}

โปรดทราบว่าขณะนี้สามารถเรียกใช้ฟังก์ชันเหล่านี้โดยใช้ Java หรือ Kotlin ด้วย ที่ตรงกับแต่ละภาษาได้

Kotlin

...
val myString: String = ...
val fooString = myString.foo()
...

Java

...
String myString = ...
String fooString = StringUtils.foo(myString);
...

ย้ายข้อมูลให้เสร็จสิ้น

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

ข้อควรพิจารณา

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

สิ่งที่คุณทำได้เพื่อสร้างความสอดคล้องเป็นฐานของโค้ด Kotlin มีดังนี้ เติบโต:

มาตรฐานการเขียนโค้ดทั่วไป

อย่าลืมกำหนดชุดกฎเกณฑ์มาตรฐานในการเขียนโค้ดตั้งแต่เนิ่นๆ ที่คุณนำมาใช้งาน ขั้นตอนได้ คุณสามารถแยกออกจาก Android คู่มือสไตล์ Kotlin ตามความเหมาะสม

เครื่องมือวิเคราะห์แบบคงที่

บังคับใช้มาตรฐานการเขียนโค้ดที่กำหนดไว้สำหรับทีมโดยใช้ Android Lint และเครื่องมือวิเคราะห์แบบคงที่อื่นๆ klint ซึ่งเป็น Kotlin บุคคลที่สาม โปรแกรมวิเคราะห์โค้ดจะมีกฎเพิ่มเติมสำหรับ Kotlin ด้วย

การผสานรวมอย่างต่อเนื่อง

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

ความสามารถในการทำงานร่วมกัน

Kotlin ทำงานร่วมกับ Java ได้อย่างราบรื่นเป็นส่วนใหญ่ แต่โปรดทราบว่า กำลังติดตาม

ความสามารถในการเว้นว่าง

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

ใช้ฟีเจอร์ใหม่

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

ด้านล่างนี้เป็นกับดักที่นักพัฒนาซอฟต์แวร์ Kotlin รุ่นใหม่ๆ พบเจอ สมมติว่า รหัส Kotlin ต่อไปนี้

val nullableFoo: Foo? = ...

// This lambda executes only if nullableFoo is not null
// and `foo` is of the non-nullable Foo type
nullableFoo?.let { foo ->
   foo.baz()
   foo.zap()
}

Intent ในตัวอย่างนี้คือการเรียกใช้ foo.baz() และ foo.zap() หาก nullableFoo ไม่เป็นค่าว่าง ดังนั้นจึงหลีกเลี่ยง NullPointerException ขณะที่รายการนี้ โค้ดทำงานได้ตามที่คาดไว้ สามารถอ่านได้ง่ายน้อยกว่าการตรวจสอบด้วยค่าว่าง Smartcast ดังที่ปรากฏในตัวอย่างต่อไปนี้

val nullableFoo: Foo? = null
if (nullableFoo != null) {
    nullableFoo.baz() // Using !! or ?. isn't required; the Kotlin compiler infers non-nullability
    nullableFoo.zap() // from guard condition; smart casts nullableFoo to Foo inside this block
}

การทดสอบ

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

พฤติกรรมเช่นนี้ทำให้เกิดปัญหาในการสร้างเฟรมเวิร์กอย่าง Mockito ซึ่ง ต้องอาศัยการใช้งานอินเทอร์เฟซหรือการสืบทอดค่าเพื่อลบล้างลักษณะการทำงานในระหว่าง การทดสอบ สำหรับการทดสอบ 1 หน่วย คุณสามารถเปิดใช้งาน Mock Maker ในหน้า ของ Mockito ซึ่งช่วยให้คุณสามารถจำลองชั้นเรียนและวิธีการขั้นสุดท้ายได้ อีกวิธีหนึ่งคือ ปลั๊กอินคอมไพเลอร์แบบเปิดทั้งหมด เพื่อเปิดคลาส Kotlin และสมาชิกที่คุณต้องการทดสอบ วิธีการคอมไพล์ ข้อดีหลักของการใช้ปลั๊กอินนี้คือทำงานได้ สำหรับทั้งการทดสอบหน่วยและการทดสอบแบบมีเครื่องวัด

ข้อมูลเพิ่มเติม

ดูข้อมูลเพิ่มเติมเกี่ยวกับการใช้ Kotlin ได้ในลิงก์ต่อไปนี้