Kotlin Academy · Les

Uw eerste SymbolProcessor schrijven

Implementeer een KSP-processor die zoekt naar geannoteerde klassen en deze logt.

Les 2 van 413 stappen

Uw eerste SymbolProcessor schrijven is een gratis Kotlin Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Kotlin Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Kotlin Academy bevat in totaal 4 lessen.

Projectstructuur

Een KSP-processor staat in een afzonderlijke Gradle-module (bijvoorbeeld :processor). De module die deze gebruikt, past de KSP-plug-in toe en declareert een ksp-afhankelijkheid op de processormodule. De processormodule zelf heeft een reguliere implementation-afhankelijkheid op de KSP-API.

KSP-afhankelijkheden toevoegen

In het bestand build.gradle.kts van je processormodule:

plugins { kotlin("jvm") }
dependencies {
    implementation("com.google.devtools.ksp:symbol-processing-api:2.0.0-1.0.21")
}

De interface SymbolProcessor

Implementeer SymbolProcessor. Het belangrijkste toegangspunt is process(resolver: Resolver): List. Retourneer symbolen die je niet kon verwerken (bijvoorbeeld symbolen waarvan de afhankelijkheden nog niet zijn opgelost), zodat ze in een tweede ronde opnieuw worden verwerkt.

import com.google.devtools.ksp.processing.*
import com.google.devtools.ksp.symbol.*

class MyProcessor(private val logger: KSPLogger,
                  private val codeGenerator: CodeGenerator) : SymbolProcessor {
    override fun process(resolver: Resolver): List<KSAnnotated> {
        val symbols = resolver.getSymbolsWithAnnotation("com.example.MyAnnotation")
        // process symbols here
        return emptyList()
    }
}

De SymbolProcessorProvider

KSP vindt je processor via een SymbolProcessorProvider. Registreer deze in resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider:

class MyProcessorProvider : SymbolProcessorProvider {
    override fun create(environment: SymbolProcessorEnvironment): SymbolProcessor =
        MyProcessor(
            logger = environment.logger,
            codeGenerator = environment.codeGenerator
        )
}

Het service-registratiebestand

Maak het bestand op het exacte pad in de resources van je processormodule:

Pad: src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider
Inhoud: de volledig gekwalificeerde naam van je klasse die SymbolProcessorProvider implementeert

Symbolen op annotatie zoeken

Gebruik resolver.getSymbolsWithAnnotation(fqn) om alle declaraties te verkrijgen die met je annotatie zijn geannoteerd. Filter op het type declaratie dat je verwacht (bijvoorbeeld klassedeclaraties):

val classes = resolver
    .getSymbolsWithAnnotation("com.example.MyAnnotation")
    .filterIsInstance<KSClassDeclaration>()

Symbolen valideren

Controleer vóór de verwerking of elk symbool volledig kan worden opgelost. Een symbool waarvan de typeverwijzingen nog niet zijn gecompileerd, is niet geldig. Retourneer zulke symbolen vanuit process() om ze in de volgende ronde opnieuw te proberen:

val (valid, deferred) = classes.partition { it.validate() }
// process valid; return deferred

Een klassedeclaratie bezoeken

Gebruik het bezoekerspatroon van KSVisitorVoid om de structuur van een klasse te doorlopen. Overschrijf visitClassDeclaration om toegang te krijgen tot eigenschappen, functies en geneste klassen:

class MyVisitor : KSVisitorVoid() {
    override fun visitClassDeclaration(classDeclaration: KSClassDeclaration, data: Unit) {
        val name = classDeclaration.simpleName.asString()
        val props = classDeclaration.getAllProperties().toList()
        println("Class: $name, props: ${props.size}")
    }
}

Registratie vanuit een processor

Gebruik KSPLogger om berichten op verschillende niveaus te versturen. logger.error() laat de build mislukken; logger.warn() drukt een waarschuwing af; logger.info() drukt een informatief bericht af dat zichtbaar is met --info.

logger.info("Processing class: ${classDeclaration.simpleName.asString()}")
logger.error("Missing required annotation", classDeclaration)

Annotaties van een symbool openen

Elke KSDeclaration heeft een reeks annotations. Gebruik filter en arguments om annotatiewaarden te lezen:

val ann = classDeclaration.annotations
    .first { it.shortName.asString() == "MyAnnotation" }
val value = ann.arguments.first { it.name?.asString() == "value" }.value as String

Hints voor incrementele verwerking

Geef KSP door van welke invoersymbolen de uitvoerbestanden afhankelijk zijn door ze te koppelen via CodeGenerator.createNewFile(dependencies = ...). Hierdoor kan KSP je processor overslaan wanneer geen van de invoersymbolen is gewijzigd.

Korte controle

Hoe vindt KSP jouw implementatie van SymbolProcessorProvider?

Beantwoord dit in de interactieve les

Samenvatting: je eerste SymbolProcessor schrijven

Belangrijkste punten:

Implementeer SymbolProcessor en SymbolProcessorProvider in een afzonderlijke module
Registreer de provider via META-INF/services/
Gebruik resolver.getSymbolsWithAnnotation() om geannoteerde symbolen te vinden
Valideer symbolen vóór de verwerking en retourneer niet-opgeloste symbolen om ze opnieuw te proberen
Gebruik KSPLogger voor berichten tijdens het bouwen en CodeGenerator om bestanden te schrijven

Gratis beginnen

Leer Kotlin met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 51
Lessen: 203

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Uw eerste SymbolProcessor schrijven” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Kotlin Academy, waaronder “Uw eerste SymbolProcessor schrijven”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Kotlin Academy bevat in totaal 4 lessen.

Wat leer ik in “Uw eerste SymbolProcessor schrijven”?

Implementeer een KSP-processor die zoekt naar geannoteerde klassen en deze logt. Je oefent met Kotlin Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Kotlin Academy te beginnen?

Ervaring vooraf is niet nodig. Kotlin Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Uw eerste SymbolProcessor schrijven”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Kotlin Academy?

Ja. Elke les over Kotlin Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

KSP versus KAPT: waarom KSP sneller is
Uw eerste SymbolProcessor schrijven
Kotlin-bronbestanden genereren met KotlinPoet
KSP-processors integreren in een Gradle-build

← Terug naar Kotlin Academy