GraphQL API mit Kotlin: Schritt-für-Schritt-Tutorial in der Praxis

Einleitung: Warum GraphQL und Kotlin ein perfektes Paar sind?

In der modernen Webentwicklung bestimmt die Wahl des richtigen Werkzeugs zur Erstellung einer API die Entwicklungsgeschwindigkeit und die Wartungsfreundlichkeit. GraphQL ist eine Abfragesprache, die es Clients ermöglicht, nur die Daten anzufordern, die sie benötigen, wodurch die Probleme des Über- und Unterabrufens, die REST inhärent sind, vermieden werden. Kotlin wiederum ist eine moderne, prägnante und sichere Sprache, die sich ideal für die Backend-Entwicklung eignet, insbesondere in Verbindung mit Spring Boot.

In diesem Tutorial werden wir praktisch eine vollwertige GraphQL-API in Kotlin erstellen. Sie lernen, wie Sie einen Server einrichten, ein Schema definieren, Abfragen und Mutationen implementieren und die fertige API testen. Am Ende des Artikels haben Sie ein funktionierendes Projekt, das als Grundlage für Ihre Anwendungen dienen kann.

1. Projekteinrichtung und Abhängigkeiten

Erstellen wir zunächst ein neues Spring Boot-Projekt mit GraphQL-Unterstützung. Wir werden Spring for GraphQL verwenden – die offizielle Integration, die die Arbeit so einfach wie möglich macht.

1.1. Projekt erstellen

Sie können Spring Initializr oder eine beliebige IDE (IntelliJ IDEA) verwenden. Fügen Sie die folgenden Abhängigkeiten hinzu:

• Spring Web
• Spring for GraphQL
• Spring Data JPA
• H2-Datenbank (der Einfachheit halber)

Die Datei build.gradle.kts sollte die folgenden Zeilen enthalten:

dependencies {    implementation("org.springframework.boot:spring-boot-starter-web")    implementation("org.springframework.boot:spring-boot-starter-graphql")    implementation("org.springframework.boot:spring-boot-starter-data-jpa")    runtimeOnly("com.h2database:h2")    testImplementation("org.springframework.boot:spring-boot-starter-test")}

1.2. Konfiguration

Erstellen wir eine einfache Book-Entität und ein Repository für die Arbeit mit der Datenbank.

// Book.kt@Entitydata class Book(    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)    val id: Long = 0,    val title: String,    val author: String,    val year: Int)

// BookRepository.ktinterface BookRepository : JpaRepository<Book, Long>

2. Erstellen des GraphQL-Schemas und des Controllers

GraphQL verwendet eine strenge Typisierung. Das Schema definiert, welche Daten verfügbar sind und wie sie abgefragt werden können. In Spring for GraphQL kann das Schema mithilfe von Annotationen beschrieben werden.

2.1. Schema per Code definieren

Erstellen wir eine Controller-Klasse, die GraphQL-Abfragen verarbeitet. Verwenden Sie die Annotation @QueryMapping zum Lesen von Daten und @MutationMapping für Änderungen.

// BookController.kt@Controllerclass BookController(private val repository: BookRepository) {

    @QueryMapping    fun allBooks(): List<Book> = repository.findAll()

    @QueryMapping    fun bookById(@Argument id: Long): Book? = repository.findById(id).orElse(null)

    @MutationMapping    fun addBook(@Argument title: String, @Argument author: String, @Argument year: Int): Book {        val book = Book(title = title, author = author, year = year)        return repository.save(book)    }

    @MutationMapping    fun deleteBook(@Argument id: Long): Boolean {        if (repository.existsById(id)) {            repository.deleteById(id)            return true        }        return false    }}

2.2. Alternative: .graphqls-Schemadatei

Sie können das Schema auch in einer separaten Datei schema.graphqls im Ordner resources/graphql definieren:

type Query {    allBooks: [Book]    bookById(id: ID!): Book}

type Mutation {    addBook(title: String!, author: String!, year: Int!): Book    deleteBook(id: ID!): Boolean}

type Book {    id: ID!    title: S