0Pricing
Kotlin Academy · Lezione

KSP e KAPT: perché KSP è più veloce

Confronti i modelli di elaborazione di KSP e KAPT e comprenda i vantaggi in termini di prestazioni.

KSP e KAPT: perché KSP è più veloce è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Il problema dell'elaborazione delle annotazioni

I processori di annotazioni generano codice in fase di build. Per anni, i progetti Kotlin hanno utilizzato KAPT — Kotlin Annotation Processing Tool — che converte il codice sorgente Kotlin in stub Java prima di passarli ai processori di annotazioni Java. Questa conversione è costosa.

Come funziona KAPT

KAPT esegue il compilatore Kotlin per produrre file stub Java, quindi esegue i processori di annotazioni Java (APT) su tali stub e infine compila tutto insieme. Ogni fase della build aggiunge latenza:

  • Compilazione da Kotlin a stub Java
  • Elaborazione APT Java sugli stub
  • Compilazione finale di Kotlin e del codice sorgente generato

Come funziona KSP

KSP (Kotlin Symbol Processing) opera direttamente sull'API dei plugin del compilatore Kotlin. Legge nativamente l'albero sintattico astratto (AST) di Kotlin: non genera stub e non utilizza intermediari Java. I processori implementano SymbolProcessor e attraversano oggetti KSNode.

Confronto della velocità

I dati dei benchmark di Google mostrano che KSP è fino a 2 volte più veloce di KAPT nelle build incrementali e significativamente più veloce nelle build pulite. Il risparmio deriva dall'eliminazione della generazione degli stub, che nei progetti di grandi dimensioni può rappresentare il 30–50% del tempo di build di KAPT.

Elaborazione incrementale

KSP supporta nativamente l'elaborazione incrementale: vengono rielaborati solo i simboli modificati dall'ultima build. KAPT offre un supporto incrementale limitato. Per basi di codice di grandi dimensioni soggette a frequenti modifiche di piccola entità, la differenza è notevole.

Differenze tra le API

I processori KAPT implementano javax.annotation.processing.AbstractProcessor (API Java). I processori KSP implementano com.google.devtools.ksp.processing.SymbolProcessor (API Kotlin con costrutti nativi di Kotlin come sealed class e funzioni di estensione).

Informazioni sui tipi native di Kotlin

Poiché KSP legge direttamente l'AST Kotlin, riconosce costrutti specifici di Kotlin che gli stub KAPT non possono rappresentare fedelmente: la nullability, i valori predefiniti dei parametri, le funzioni di estensione, le dichiarazioni expect/actual e le inline class.

Supporto multipiattaforma

KSP 2.x supporta Kotlin Multiplatform. Un singolo processore KSP può generare codice per i target JVM, JS e Native. KAPT è disponibile solo su JVM e non può elaborare le sorgenti commonMain di KMP.

Percorso di migrazione da KAPT a KSP

La maggior parte delle librerie più diffuse dispone di varianti KSP: Room (KSP), Hilt (KSP), Moshi (KSP), Dagger (parziale). Consulti la documentazione della libreria. Sostituisca kapt("...") con ksp("...") nella build e rimuova il plugin KAPT dopo aver migrato tutti i processori.

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

Quando è ancora necessario KAPT

Utilizzi KAPT quando una libreria non dispone ancora di una variante del processore KSP. È possibile combinare KAPT e KSP nello stesso progetto, ma ciò non elimina l'overhead della generazione degli stub per i processori KAPT.

Strumenti e debug

I processori KSP possono registrare messaggi con diversi livelli di gravità (KSPLogger). I file generati si trovano in build/generated/ksp/. Il supporto dell'IDE (IntelliJ / Android Studio) evidenzia le sorgenti generate e consente di raggiungerle.

Verifica rapida

Perché KSP è più veloce di KAPT nelle build incrementali?

Riepilogo: KSP e KAPT a confronto

Punti chiave:

  • KAPT: converte Kotlin in stub Java, quindi esegue APT Java — è lento e disponibile solo su JVM
  • KSP: legge nativamente l'AST Kotlin tramite un plugin del compilatore — è fino a 2 volte più veloce
  • KSP supporta l'elaborazione incrementale e Kotlin Multiplatform
  • KSP riconosce i costrutti specifici di Kotlin che gli stub KAPT non possono rappresentare
  • Esegua la migrazione sostituendo kapt() con ksp() quando la libreria lo supporta

Domande Frequenti

La lezione «KSP e KAPT: perché KSP è più veloce» è gratuita?

Sì — il testo completo di «KSP e KAPT: perché KSP è più veloce» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «KSP e KAPT: perché KSP è più veloce»?

Confronti i modelli di elaborazione di KSP e KAPT e comprenda i vantaggi in termini di prestazioni. Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «KSP e KAPT: perché KSP è più veloce»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. KSP e KAPT: perché KSP è più veloce
  2. Scrivere il primo SymbolProcessor
  3. Generare file sorgente Kotlin con KotlinPoet
  4. Integrare i processori KSP in una build Gradle
← Torna a Kotlin Academy