0Pricing
Kotlin Academy · Leçon

KSP ou KAPT : pourquoi KSP est plus rapide

Comparez les modèles de traitement de KSP et KAPT et comprenez les avantages en matière de performances.

KSP ou KAPT : pourquoi KSP est plus rapide est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

Le problème du traitement des annotations

Les processeurs d’annotations génèrent du code au moment de la compilation. Pendant des années, les projets Kotlin ont utilisé KAPT — outil de traitement des annotations de Kotlin — qui convertit le code source Kotlin en fichiers squelettes Java avant de les transmettre aux processeurs d’annotations Java. Cette conversion est coûteuse.

Fonctionnement de KAPT

KAPT exécute le compilateur Kotlin pour produire des fichiers squelettes Java, puis exécute les processeurs d’annotations Java (APT) sur ces squelettes, avant de tout compiler ensemble. Chaque étape de compilation ajoute de la latence :

  • Compilation de Kotlin vers des squelettes Java
  • Traitement Java APT sur les squelettes
  • Compilation finale de Kotlin et des sources générées

Fonctionnement de KSP

KSP (traitement des symboles Kotlin) s’exécute directement via l’API de plug-in du compilateur Kotlin. Il lit nativement l’arbre syntaxique abstrait Kotlin (AST) — sans génération de squelettes ni intermédiaire Java. Les processeurs implémentent SymbolProcessor et parcourent des objets KSNode.

Comparaison des vitesses

Les données de référence de Google montrent que KSP est jusqu’à deux fois plus rapide que KAPT lors des compilations incrémentielles, et nettement plus rapide lors des compilations propres. Le gain vient de la suppression de la génération des squelettes, qui peut représenter 30 à 50 % du temps de compilation de KAPT dans les grands projets.

Traitement incrémentiel

KSP prend nativement en charge le traitement incrémentiel : seuls les symboles modifiés depuis la dernière compilation sont traités à nouveau. KAPT offre une prise en charge incrémentielle limitée. Pour les grandes bases de code soumises à de fréquentes petites modifications, la différence est considérable.

Différences d’API

Les processeurs KAPT implémentent javax.annotation.processing.AbstractProcessor (API Java). Les processeurs KSP implémentent com.google.devtools.ksp.processing.SymbolProcessor (API Kotlin avec des constructions natives de Kotlin, telles que les classes scellées et les fonctions d’extension).

Informations de type natives de Kotlin

Comme KSP lit directement l’AST Kotlin, il voit des constructions propres à Kotlin que les squelettes KAPT ne peuvent pas représenter fidèlement : la nullabilité, les valeurs de paramètres par défaut, les fonctions d’extension, les déclarations expect/actual et les classes inline.

Prise en charge multiplateforme

KSP 2.x prend en charge Kotlin Multiplatform. Un seul processeur KSP peut générer du code pour les cibles JVM, JS et Native. KAPT est limité à la JVM et ne peut pas traiter les sources commonMain de KMP.

Procédure de migration de KAPT vers KSP

La plupart des bibliothèques populaires proposent des variantes KSP : Room (KSP), Hilt (KSP), Moshi (KSP) et Dagger (partiellement). Consultez la documentation de la bibliothèque. Remplacez kapt("...") par ksp("...") dans votre compilation et supprimez le plug-in KAPT une fois tous les processeurs migrés.

plugins {
    id("com.google.devtools.ksp") version "2.0.0-1.0.21"
}
dependencies {
    ksp("androidx.room:room-compiler:2.6.1")
}

Quand KAPT reste nécessaire

Utilisez KAPT lorsqu’une bibliothèque ne propose pas encore de variante de processeur KSP. Mélanger KAPT et KSP dans un même projet est pris en charge, mais cela ne supprime pas la surcharge de génération des squelettes de KAPT pour les processeurs KAPT.

Outils et débogage

Les processeurs KSP peuvent consigner des messages à différents niveaux de gravité (KSPLogger). Les fichiers générés apparaissent dans build/generated/ksp/. La prise en charge par les environnements de développement intégrés (IntelliJ / Android Studio) met en évidence les sources générées et permet d’y accéder.

Vérification rapide

Pourquoi KSP est-il plus rapide que KAPT lors des compilations incrémentielles ?

Récapitulatif : KSP et KAPT

Points essentiels :

  • KAPT : convertit Kotlin en squelettes Java, puis exécute Java APT — lent et limité à la JVM
  • KSP : lit nativement l’AST Kotlin via le plug-in du compilateur — jusqu’à deux fois plus rapide
  • KSP prend en charge le traitement incrémentiel et Kotlin Multiplatform
  • KSP voit les constructions propres à Kotlin que les squelettes KAPT ne peuvent pas représenter
  • Migrez en remplaçant kapt() par ksp() lorsque la bibliothèque le prend en charge

Questions Fréquemment Posées

La leçon « KSP ou KAPT : pourquoi KSP est plus rapide » est-elle gratuite ?

Oui — le texte complet de « KSP ou KAPT : pourquoi KSP est plus rapide » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « KSP ou KAPT : pourquoi KSP est plus rapide » ?

Comparez les modèles de traitement de KSP et KAPT et comprenez les avantages en matière de performances. Tu pratiques Kotlin Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « KSP ou KAPT : pourquoi KSP est plus rapide » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Kotlin Academy ?

Oui. Chaque leçon Kotlin Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. KSP ou KAPT : pourquoi KSP est plus rapide
  2. Écrire votre premier SymbolProcessor
  3. Générer des fichiers source Kotlin avec KotlinPoet
  4. Intégrer des processeurs KSP dans une compilation Gradle
← Retour à Kotlin Academy