Kotlin für große Teams anwenden

Der Wechsel in eine andere Sprache kann eine gewaltige Aufgabe sein. Das Erfolgsrezept besteht darin, beginnen Sie langsam, bewegen Sie sich in Abschnitten und testen Sie häufig, um Ihr Team auf Erfolgskurs zu bringen. Kotlin vereinfacht die Migration, da es in JVM-Bytecode kompiliert und vollständig interoperabel mit Java ist.

Aufbau des Teams

Der erste Schritt vor der Migration besteht darin, für Ihr Team. Mit den folgenden Tipps können Sie Ihre auf den Lernfortschritt des Teams.

Lerngruppen bilden

Lerngruppen sind eine effektive Möglichkeit, das Lernen und die Bindung zu fördern. Studien schlagen vor das Gelernte in einer Gruppe zu reflektieren, um das Material zu verstärken. Erhalte Kotlin-Buch oder anderes für jedes Mitglied der Gruppe und bitten Sie die Gruppe, jede Woche kommen ein paar Kapitel zusammen. Während jeder Besprechung sollte die Gruppe vergleichen, und besprechen Fragen oder Beobachtungen.

Eine Unterrichtskultur aufbauen

Nicht jeder betrachten sich selbst als Lehrer, aber jeder kann unterrichten. Vom Technologie- oder Teamleiter bis hin zum einzelnen Beitragenden: eine Lernumgebung schaffen, die zum Erfolg beitragen kann. Eine Möglichkeit, um indem Sie regelmäßige Präsentationen halten, in denen eine Person aus dem Team ist dafür gedacht, über etwas zu reden, das sie gelernt hat oder teilen möchte. Sie können Ihre Studiengruppe optimal nutzen, indem Sie die Freiwilligen bitten, jeweils ein neues Kapitel vorzuschlagen bis Sie so weit sind, dass Ihr Team sich mit der Sprache.

Einen Champion ernennen

Bestimmen Sie schließlich einen Champion, der eine Lerninitiative leitet. Diese Person kann als Fachleute zustimmen, während Sie mit der Akzeptanz beginnen. Es ist ist es wichtig, diese Person bei allen Ihren Übungsmeetings zum Thema Kotlin Im Idealfall interessiert sich diese Person bereits für Kotlin und hat Arbeitswissen.

Langsame Integration

Fangen Sie langsam an und denken Sie strategisch darüber nach, welche Teile Ihres Ökosystems ist der Schlüssel zum Erfolg. Es ist oft am besten, dies auf eine einzelne App im Unternehmen und nicht nur eine Flagship-App. In Bezug auf die Migration der ausgewählten App ist jede Situation anders, aber hier sind ein paar häufige Ausgangspunkte.

Datenmodell

Ihr Datenmodell besteht wahrscheinlich aus vielen Statusinformationen . Das Datenmodell kann auch gängige Methoden wie toString(), equals() und hashcode(). Diese Methoden können in der Regel umgestellt werden einfach isoliert getestet werden.

Nehmen wir zum Beispiel das folgende Java-Snippet an:

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 + '\'' +
               '}';
   }
}

Sie können die Java-Klasse durch eine einzelne Zeile von Kotlin ersetzen, wie hier gezeigt:

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

Dieser Code kann dann mit der aktuellen Testsuite getestet werden. Die Idee hier beginnen Sie klein mit einem Modell nach dem anderen und Übergangsklassen, die vor allem der Zustand und kein Verhalten. Testen Sie dabei regelmäßig.

Tests migrieren

Ein weiterer möglicher Ausgangspunkt besteht darin, vorhandene Tests zu konvertieren und mit dem Schreiben neue Tests in Kotlin. So hat Ihr Team genug Zeit, sich mit den Sprache, bevor Sie Code schreiben, den Sie mit Ihrer App ausliefern möchten.

Dienstprogrammmethoden in Erweiterungsfunktionen verschieben

Alle statischen Dienstprogrammklassen (StringUtils, IntegerUtils, DateUtils, YourCustomTypeUtils usw.) dargestellt werden können als Kotlin-Erweiterungsfunktionen und von Ihrer vorhandenen Java-Codebasis verwendet.

Angenommen, Sie haben eine StringUtils-Klasse mit mehreren Methoden:

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
   }

}

Diese Methoden können dann an anderer Stelle in Ihrer App verwendet werden, wie in den folgendes Beispiel:

...

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

...

Mit Kotlin-Erweiterungsfunktionen können Sie dieselbe Utils-Schnittstelle für und gleichzeitig eine kürzere API für Ihre mit zunehmender Kotlin-Codebasis.

Dazu können Sie diese Utils-Klasse mithilfe der Methode automatische Konvertierung durch die IDE. Die Beispielausgabe sieht in etwa so aus: Folgendes:

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
   }

}

Entfernen Sie als Nächstes die Klasse oder Objektdefinition und stellen Sie jedem Funktionsnamen das Präfix -Typ, auf den diese Funktion angewendet werden soll, und verweise damit auf den Typ innerhalb der Funktion, wie im folgenden Beispiel gezeigt:

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
}

Fügen Sie abschließend oben in der Quelldatei eine JvmName-Anmerkung hinzu, kompilierter Name, der mit dem Rest Ihrer App kompatibel ist, wie im Folgenden gezeigt. Beispiel:

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

Die endgültige Version sollte in etwa so aussehen:

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

Diese Funktionen können jetzt in Java oder Kotlin mit die den jeweiligen Sprachen entsprechen.

Kotlin

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

Java

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

Migration abschließen

Sobald Ihr Team mit Kotlin vertraut ist und Sie kleinere Bereiche migriert haben, können Sie mit größeren Komponenten wie Fragmenten, Aktivitäten, ViewModel-Objekte und andere Klassen, die mit Geschäftslogik zusammenhängen.

Wissenswertes

Ähnlich wie bei Java hat Kotlin einen eigenen idiomatischen Stil, was zu ihrer Prägnanz beiträgt. Vielleicht stellen Sie jedoch anfangs fest, Der von Ihrem Team erstellte Kotlin-Code ähnelt eher dem Java-Code, der ersetzt wird. Das ändert sich mit zunehmender Kotlin-Erfahrung Ihres Teams. Denken Sie daran, schrittweise ist Veränderung der Schlüssel zum Erfolg.

Hier sind einige Dinge, die Sie tun können, um für Konsistenz der Kotlin-Codebasis zu sorgen wächst:

Gängige Codierungsstandards

Definieren Sie frühzeitig im Rahmen der Einführung einen Standardsatz von Codierungskonventionen. . Sie können vom Android- Kotlin-Styleguide, sofern sinnvoll.

Tools für statische Analysen

Erzwingen Sie die für Ihr Team festgelegten Codierungsstandards mithilfe von Android Lint und andere statische Analysetools klint, ein Kotlin-Drittanbieter Linter bietet auch zusätzliche Regeln für Kotlin.

Continuous Integration

Achten Sie darauf, dass Sie gängige Codierungsstandards einhalten, und bieten Sie ausreichende Tests an. für Ihren Kotlin-Code. Diesen Schritt in einen automatisierten Build-Prozess einbinden können Sie für Konsistenz und Einhaltung dieser Standards sorgen.

Interoperabilität

Kotlin funktioniert größtenteils nahtlos mit Java. folgen.

Null-Zulässigkeit

Kotlin nutzt Annotationen zur Null-Zulässigkeit im kompilierten Code, um die Null-Zulässigkeit abzuleiten. auf der Kotlin-Seite. Wenn keine Annotationen angegeben werden, wird in Kotlin standardmäßig eine Plattformtyp, der als Typ behandelt werden kann, für den Nullwerte zulässig sind, oder als Typ, der keine Nullwerte zulässt. Dieses kann jedoch zu NullPointerException-Laufzeitproblemen führen, wenn sie nicht behandelt wird vorsichtig zu sein.

Neue Funktionen einführen

Kotlin bietet viele neue Bibliotheken und syntaktischen Zucker, um die Entwicklung von Textbausteinen zu reduzieren Geschwindigkeit. Seien Sie bei der Verwendung des Kotlin-Standards Bibliotheksfunktionen wie Sammlungsfunktionen, coroutines, und Lambdas.

Hier ist ein häufiger Fehler, auf den neue Kotlin-Entwickler stoßen. Angenommen, folgenden Kotlin-Code:

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()
}

Der Intent in diesem Beispiel ist es, foo.baz() und foo.zap() auszuführen, wenn nullableFoo ist nicht null, wodurch ein NullPointerException vermieden wird. Während dies funktioniert, ist das Lesen weniger intuitiv als eine einfache Nullprüfung Smart Cast, Dies wird im folgenden Beispiel gezeigt:

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
}

Testen

Klassen und ihre Funktionen sind in Kotlin standardmäßig zur Erweiterung geschlossen. Ich muss explizit die Klassen und Funktionen öffnen, von denen Sie Unterklassen erstellen möchten. Dieses ist eine Entscheidung im Sprachdesign, die gewählt wurde, Vorrang vor Vererbung. Kotlin bietet eine integrierte Unterstützung für Delegierung um die Zusammenstellung zu vereinfachen.

Dieses Verhalten stellt ein Problem für Mocking-Frameworks wie Mockito dar, auf die Implementierung oder Vererbung von Schnittstellen angewiesen sind, um Verhaltensweisen Tests durchführen. Für Einheitentests können Sie die Verwendung des Mock Maker Inline Mockito-Funktion, mit der Sie endgültige Klassen und Methoden simulieren können. Alternativ können Sie den All-Open-Compiler-Plug-in um alle Kotlin-Klassen und ihre Mitglieder zu öffnen, die Sie im Rahmen des Kompilierungsprozess. Der Hauptvorteil dieses Plug-ins ist, dass es mit Einheitentests und instrumentierten Tests.

Weitere Informationen

Weitere Informationen zur Verwendung von Kotlin finden Sie unter den folgenden Links: