Une histoire sur un projet Spring Boot écrit en Java qui prend en charge Kotlin

Contexte

Les ingénieurs de l'équipe NOREL sont en train de moderniser la technologie utilisée, et il y a eu un discours disant que "je veux quand même écrire un système écrit en Java / Spring Boot à Kotlin", donc je vais procéder à la correspondance pour qu'il puisse être développé dans Kotlin. Je suis.

Je vois souvent des articles comme commencer par Kotlin (Gradle) depuis le début, mais je n'ai pas trouvé beaucoup d'articles qui correspondent à Kotlin (Maven) alors qu'il était écrit en Java, alors j'ai essayé de m'en occuper.

Environnement existant

• macOS High Sierra
• JDK version => 1.8
• Spring Boot => 1.5.8 --Utilisation de Lombok --Construire le système => Maven --Il y a une faction IntelliJ et une faction STS «Je suis le premier.

Fondamentalement, Spring Boot implémente uniquement l'API REST.

Politique de support de Kotlin

• Puisque le développement en Java progresse en parallèle, la conversion de tout le code de Java vers Kotlin sera reportée cette fois. --Controller / Service peut être écrit en Kotlin
• Laissez la couche d'accès aux données telle que JPA en Java ――Je veux faire tout Kotlin à la fin

De plus, ce travail a été effectué sur IntelliJ.

Travaux de migration

Paramètres pom.xml

• Pour les paramètres pom.xml, je me suis référé au site officiel de Kotlin suivant.
• using-maven
• compiler-plugins

• La description se concentre sur les parties liées à ce poste.

• Définition de la version de Kotlin

pom.xml

  <properties>
...
     <java.version>1.8</java.version>
+    <kotlin.version>1.2.10</kotlin.version>
+    <kotlin.compiler.incremental>true</kotlin.compiler.incremental>
  </properties>

• Ajout des bibliothèques dépendantes de Kotlin

pom.xml

  <dependencies>
・ ・ ・
+    <dependency>
+      <groupId>org.jetbrains.kotlin</groupId>
+      <artifactId>kotlin-stdlib</artifactId>
+      <version>${kotlin.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.jetbrains.kotlin</groupId>
+      <artifactId>kotlin-reflect</artifactId>
+      <version>${kotlin.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.jetbrains.kotlin</groupId>
+      <artifactId>kotlin-test</artifactId>
+      <version>${kotlin.version}</version>
+      <scope>test</scope>
+    </dependency>
  </dependencies>

--Construire les paramètres

À l'origine, je n'utilisais pas maven-compiler-plugin, mais chaque paquet est prêt pour le développement en Java et Kotlin.

• src/main/java
• src/main/kotlin
• scr/test/java
• src/test/kotlin

J'utilise maven-compiler-plugin pour séparer par.

De plus, spring est défini comme compilerPlugins afin que diverses annotations utilisées dans Spring puissent être utilisées. Comme mentionné dans la documentation, la définition d'un plug-in à ressort semble éliminer le besoin de définir tout-ouvert.

pom.xml

  <build>
     <finalName>${project.name}</finalName>
-    <sourceDirectory>src/main/java</sourceDirectory>
-    <testSourceDirectory>src/test/java</testSourceDirectory>
    <resources>
      <resource>
        <directory>${resources.directory}</directory>
      </resource>
      <resource>
        <directory>src/main/resources</directory>
      </resource>
     </resources>
     <testResources>
       <testResource>
         <directory>src/test/resources</directory>
       </testResource>
     </testResources>
     <plugins>
       <plugin>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-maven-plugin</artifactId>
         <configuration>
           <executable>true</executable>
         </configuration>
       </plugin>
+      <plugin>
+        <artifactId>kotlin-maven-plugin</artifactId>
+        <groupId>org.jetbrains.kotlin</groupId>
+        <version>${kotlin.version}</version>
+        <configuration>
+          <compilerPlugins>
+            <plugin>spring</plugin>
+          </compilerPlugins>
+        </configuration>
+        <executions>
+          <execution>
+            <id>compile</id>
+            <goals> <goal>compile</goal> </goals>
+            <configuration>
+              <sourceDirs>
+                <sourceDir>${project.basedir}/src/main/kotlin</sourceDir>
+                <sourceDir>${project.basedir}/src/main/java</sourceDir>
+              </sourceDirs>
+            </configuration>
+          </execution>
+          <execution>
+            <id>test-compile</id>
+            <goals> <goal>test-compile</goal> </goals>
+            <configuration>
+              <sourceDirs>
+                <sourceDir>${project.basedir}/src/test/kotlin</sourceDir>
+                <sourceDir>${project.basedir}/src/test/java</sourceDir>
+              </sourceDirs>
+            </configuration>
+          </execution>
+        </executions>
+        <dependencies>
+          <dependency>
+            <groupId>org.jetbrains.kotlin</groupId>
+            <artifactId>kotlin-maven-allopen</artifactId>
+            <version>${kotlin.version}</version>
+          </dependency>
+        </dependencies>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.5.1</version>
+        <executions>
+          <!-- Replacing default-compile as it is treated specially by maven -->
+          <execution>
+            <id>default-compile</id>
+            <phase>none</phase>
+          </execution>
+          <!-- Replacing default-testCompile as it is treated specially by maven -->
+          <execution>
+            <id>default-testCompile</id>
+            <phase>none</phase>
+          </execution>
+          <execution>
+            <id>java-compile</id>
+            <phase>compile</phase>
+            <goals> <goal>compile</goal> </goals>
+          </execution>
+          <execution>
+            <id>java-test-compile</id>
+            <phase>test-compile</phase>
+            <goals> <goal>testCompile</goal> </goals>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
  </build>

Vous êtes maintenant prêt à écrire Kotlin sur IntelliJ.

Prise en charge de STS (Eclipse)

Quand j'ai demandé aux membres qui utilisent habituellement STS pour la correspondance jusqu'à présent, cela n'a pas bien fonctionné et j'en étais un peu accro, alors je vais également décrire comment gérer STS.

--Installez le Kotlin Plugin for Eclipse depuis le marché Eclipse.

• Puisque src / main / kotlin n'est pas reconnu comme chemin de construction, vérifiez le dossier kotlin avec Ajouter un fichier à partir de la source de Projets> Propriétés> Chemin de construction Java. La même chose s'applique à src / test / kotlin

• Faites un clic droit sur le projet et exécutez Configurer Kotlin> Ajouter Kotlin Nature

Dans la figure ci-dessous, il ne peut pas être sélectionné car il a déjà été ajouté Kotlin Nature, mais il peut être sélectionné avant l'exécution.

Maintenant, il se compile sur STS et vous pouvez développer sur Kotlin.

Ecrire Kotlin

Convertir du code Java en code Kotlin

Comme la fonction de conversion d'IntelliJ est excellente, je l'ai essentiellement convertie avec IntelliJ. C'est effrayant de les assembler tous à la fois, alors j'ai converti un ou plusieurs codes à la fois.

Sélectionnez le code que vous souhaitez convertir et convertissez-le en code Kotlin avec Code> Convertir le fichier Java en fichier Kotlin.

• Comme nous faisons parfois des conversions étranges, nous les corrigerons à la main à chaque fois.

De plus, puisque le paquet est toujours sous src / main / java, déplacez-le sous le même paquet sous src / main / kotlin. Cela permet également de bien refactoriser avec Refactor> Move ... dans IntelliJ.

DI (câblé automatiquement, etc.)

Par exemple, le code ci-dessous

@Service
public class HogeService {
    @Autowired
    private HogeRepository hogeRepository;
}

Dans Kotlin, il peut être déclaré avec late init, mais cette fois, il est défini avec constructor injection.

@Service
class HogeService(
    private val hogeRepository: HogeRepository
) {
}

Autour de Lombok

Lors de l'utilisation de Lombok, j'ai parfois une erreur de compilation lors de la conversion vers Kotlin.

Fondamentalement, la classe qui se convertit en Kotlin et la classe référencée à partir de Kotlin sont résolues par Delombok.

• Delombok

Utilisez le plug-in lombok d'IntelliJ. Il supprime la conversion Lombok de Refactor> Delombok.

• Annotation SLF4J

Vous pouvez omettre la déclaration du journal et écrire du code qui génère soudainement des journaux. Si vous utilisez Kotlin, le code suivant ne pourra pas résoudre la variable de journal et entraînera une erreur de compilation.

@Service
@Slf4j
public class HogeService {
    public void hoge() {
        log.info("hoge");
    }
}

Dans kotlin, il peut être utilisé en initialisant le logger avec objet compagnon.

@Service
class HogeService {
    companion object {
        private val log = LoggerFactory.getLogger(HogeService::class.java)
    }
}

Certaines personnes ont essayé la méthode DI avec annotations, alors j'aimerais envisager de la rendre plus facile. http://saiya-moebius.hatenablog.com/entry/2017/11/08/033932

• Annotation des données

J'ai lu le code Java Lombokized suivant de Kotlin, et quand j'essaye d'obtenir le hoge, il dit qu'il est privé et non accessible. Dans ce cas, comme décrit ci-dessus, il a été converti en Delombok. (Si tout devient Kotlin, vous n'êtes pas obligé d'utiliser Lombok en premier lieu ...)

@Entity
@Data
@EqualsAndHashCode(callSuper = false)
@ToString(callSuper = true)
public class Hoge extends AbstractEntity {
	@Column(name = "hoge")
	private String hoge;
}

À propos du futur

Pour le moment, un certain code est maintenant Kotlinized et fonctionne. Cependant, j'ai eu des problèmes à plusieurs reprises pendant que j'écrivais le code, il est donc possible que je continue à avoir des problèmes. Je pense que je devrais ajouter de plus en plus comment y faire face.

• Kotlin est amusant !!