Wdrożenie Kotlin w dużych zespołach

Przejście na nowy język może być trudne. Przepisem na sukces jest zaczynaj powoli, przesyłaj kolejne partie i często testuj, aby Twój zespół odniósł sukces. Kotlin ułatwia migrację, ponieważ kompiluje kod bajtowy JVM jest w pełni kompatybilny z Javą.

Budowanie zespołu

Pierwszym krokiem przed migracją jest zbudowanie punktu odniesienia dla Twojego zespołu. Oto kilka wskazówek, które pomogą Ci przyspieszyć w tym zespole.

Grupy do badania formy

Grupy uczniów to skuteczny sposób na ułatwienie nauki i utrzymania uwagi. Badania pokazują rekomendowanie treści nabytych w grupie pomaga wzmacniać materiał. Zdobądź Książka Kotlin lub inna zapoznaj się z materiałami dla każdego członka grupy i poproś, aby zapoznała się z kilka rozdziałów w każdym tygodniu. Podczas każdego spotkania grupa powinna porównać to, co czego się nauczyły, i omówić wszelkie pytania bądź obserwacje.

Kultura nauczania

Nie każdy chce być nauczycielem, ale każdy może uczyć. Od technologii lub zespołu po współtwórcę – każdy może tworzyć środowisko edukacyjne, które może pomóc w osiągnięciu sukcesu. W jedną stronę ułatwiają organizowanie okresowych prezentacji, w których jedna osoba z zespołu jest przeznaczona do opowiadania o czymś, czego się nauczyło lub którym chce się podzielić. Dostępne opcje wykorzystaj grupę badawczą, prosząc ochotników o przedstawienie każdego nowego rozdziału do momentu, gdy zespół poczuje się komfortowo język.

Wyznacz mistrza

Na koniec wyznacz osoby, które poprowadzą zajęcia edukacyjne. Ta osoba może działać jako ekspertem ds. danego tematu (SME) przy rozpoczęciu procesu wdrażania. Jest ważne jest uwzględnianie tej osoby na wszystkich spotkaniach praktycznych związanych z Kotlin. Najlepiej, jeśli ta osoba już pasjonuje się Kotlinem i ma pewne praktyczna wiedza.

Powolna integracja

Zacznij powoli i strategicznie myśl o tym, które części ekosystemu pierwszy ruch jest kluczowy. Często najlepiej jest ograniczyć to do jednej aplikacji dla organizacji, a nie sztandarowej aplikacji. Jeśli chodzi o migrację wybranej aplikacji, każda z tych sytuacji jest inna. Poniżej znajdziesz jednak typowe, od których warto zacząć.

Model danych

Twój model danych prawdopodobnie składa się z wielu informacji o stanie . Model danych może też korzystać z popularnych metod, takich jak toString(), equals() i hashcode(). Te metody można zwykle przenieść i testowania w izolacji.

Załóżmy na przykład, że następujący fragment kodu 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 + '\'' +
               '}';
   }
}

Możesz zastąpić klasę Java jednym wierszem kodu Kotlin, jak pokazano tutaj:

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

Ten kod możesz następnie przetestować jednostkową w swoim obecnym pakiecie testowym. Idealna koncepcja jest rozpoczęcie pracy z jednym modelem i klasami przejściowymi, które są stanu, a nie zachowania. Pamiętaj, aby często przeprowadzać testy.

Migracja testów

Możesz też przekonwertować istniejące testy i zacząć pisać. nowych testów w Kotlin. Dzięki temu zespół będzie miał czas na przed napisaniem kodu, który chcesz wysłać razem z aplikacją.

Przenoszenie metod narzędziowych do funkcji rozszerzeń

Wszystkie statyczne klasy narzędzia (StringUtils, IntegerUtils, DateUtils, YourCustomTypeUtils itd.) może być reprezentowany jako Funkcje rozszerzeń Kotlin i wykorzystywane przez istniejącą bazę kodu Java.

Załóżmy na przykład, że masz klasę StringUtils z kilkoma metodami:

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
   }

}

Tych metod możesz potem używać w innych miejscach w aplikacji, jak widać na stronie następujący przykład:

...

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

...

Za pomocą funkcji rozszerzeń Kotlin możesz udostępnić ten sam interfejs Utils do wywołujący język Java, oferując jednocześnie bardziej zwięzły interfejs API i rozbudowy bazy kodu w Kotlin.

Aby to zrobić, zacznij od przekonwertowania tej klasy Utils na Kotlin za pomocą automatyczną konwersję udostępnianą przez IDE. Przykładowe dane wyjściowe mogą wyglądać podobnie do: następujące:

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
   }

}

Następnie usuń definicję klasy lub obiektu, poprzedź nazwę każdej funkcji prefiksem do którego ma mieć zastosowanie ta funkcja, i użyj go do odwoływania się do typu wewnątrz funkcji, jak widać w tym przykładzie:

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
}

Na koniec dodaj adnotację JvmName na początku pliku źródłowego, aby skompilowaną nazwę zgodną z pozostałą częścią aplikacji, jak w tym miejscu przykład:

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

Ostateczna wersja powinna wyglądać mniej więcej tak:

@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
}

Warto zauważyć, że funkcje te można teraz wywoływać przy użyciu języka Java lub Kotlin z zgodne z poszczególnymi językami.

Kotlin

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

Java

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

Dokończ migrację

Gdy zespół opanuje Kotlin i przeprowadzisz migrację mniejszych obszarów, możesz zająć się większymi elementami, takimi jak fragmenty, działania, obiekty ViewModel i inne klasy, które są powiązane z logiką biznesową.

co należy wziąć pod uwagę

Tak jak Java ma swój własny styl, Kotlin ma własny styl idiomatyczny, co przyczynia się do jej zwięzłości. Początkowo może się jednak okazać, że Kod Kotlin, który tworzy Twój zespół, wygląda bardziej jak kod w Javie, który zastępuje. To z czasem będzie się zmieniać w miarę rozwijania przez Twój zespół platformy Kotlin. Pamiętaj, że stopniowo to klucz do sukcesu.

Oto kilka rzeczy, które możesz zrobić, aby zachować spójność w ramach bazy kodu Kotlin rośnie:

Typowe standardy kodowania

Pamiętaj, aby na wczesnym etapie wdrażania określić standardowy zestaw konwencji kodowania. proces tworzenia konta. Możesz zrobić inaczej niż na Androidzie Przewodnik po stylu Kotlin, gdzie ma sens.

Narzędzia do analizy statycznej

Egzekwuj standardy kodowania ustalone dla Twojego zespołu za pomocą Android Lint i inne narzędzia do analizy statycznej. klint, zewnętrzna firma Kotlin linter.

Tryb ciągłej integracji

Zadbaj o zgodność z popularnymi standardami kodowania i wystarczające testy dla kodu Kotlin. Uczestnictwo w zautomatyzowanym procesie kompilacji może pomóc w zapewnieniu spójności i przestrzegania tych standardów.

Interoperacyjność

Kotlin w większości bezproblemowo współpracuje z Javą, ale warto zwrócić uwagę na następujących po sobie.

Dopuszczalność wartości null

Kotlin wykorzystuje adnotacje do wartości null w skompilowanym kodzie do wnioskowania o dopuszczalności wartości null po stronie Kotlina. Jeśli adnotacje nie zostaną dodane, Kotlin domyślnie użyje typ platformy, który może być traktowany jako dopuszczający wartość null lub niedopuszczający wartości null. Ten może prowadzić do problemów w czasie działania aplikacji NullPointerException, jeśli jednak nie zostaną rozwiązane i uważnie.

Wdrażanie nowych funkcji

Kotlin zapewnia wiele nowe biblioteki oraz cukru składniowego, aby ograniczyć powtarzalność i przyspieszyć rozwój prędkość działania. Zachowaj jednak ostrożność i metodyczność przy korzystaniu ze standardu Kotlina funkcje biblioteczne, takie jak funkcje zbierania danych, współdziały, i lambda.

Oto bardzo częsta pułapka, z którą spotykają się nowi programiści Kotlin. Załóżmy, że następujący kod 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()
}

Intencją w tym przykładzie jest wykonanie funkcji foo.baz() i foo.zap(), jeśli nullableFoo nie ma wartości null, więc unikasz NullPointerException. Choć w tym roku działa zgodnie z oczekiwaniami i jest mniej intuicyjny do odczytania niż proste sprawdzanie null. smart cast, jak w tym przykładzie:

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
}

Testowanie

Klasy i ich funkcje są domyślnie zamknięte na potrzeby rozszerzenia w Kotlin. Ty musi bezpośrednio otworzyć klasy i funkcje, które chcesz podklasyfikować. Ten „Zachowanie” to decyzja dotycząca projektu językowego, która ma promować kompozycję nad dziedziczeniem. Kotlin ma wbudowaną obsługę implementacji zachowań przekazanie dostępu aby uprościć kompozycję.

Stanowi to problem w przypadku platform podszywających się pod platformę, takich jak Mockito, korzystają z implementacji lub dziedziczenia interfejsu w celu zastępowania działań i testowania. W przypadku testów jednostkowych możesz użyć funkcji Wbudowana wersja Mack Maker funkcję Mockito, która pozwala symulować ostateczne klasy i metody. Ewentualnie możesz użyć atrybutu Dodatek kompilatora All-Open aby otworzyć dowolną klasę Kotlin i jej członków, które chcesz przetestować w ramach kompilację danych. Główną zaletą korzystania z tej wtyczki jest to, że działa stosując zarówno testy jednostkowe, jak i instrumentowane.

Więcej informacji

Więcej informacji o korzystaniu z Kotlin znajdziesz tutaj: