Minimales Beispiel einer Maven-Kotlin-Querydsl-Integration

Ein minimales Beispiel von QueryDSL Integration in ein Maven-Kotlin-Spring-Boot Projekt

Veröffentlicht Zuletzt bearbeitet

Auf aktuelle Versionen und den gepflegten OpenFeign-QueryDSL-Fork aktualisiert

Inhalt

QueryDSL ist ein praktisches Werkzeug für das Vereinfachen von Datenbankzugriffen in JVM-Programmen. In diesem Beispiel habe ich QueryDSL in ein Kotlin-basiertes Spring Boot Projekt mit Maven eingebaut.

Der Code ist verfügbar auf Github

Vorraussetzungen

Für dieses Beispiel habe ich ein Projekt mithilfe des Spring Initializr generiert und Kotlin und das JPA-Modul ausgewählt. Das aktuelle Beispiel verwendet Spring Boot 4.1, Kotlin 2.4, Java 17+ und den gepflegten OpenFeign-QueryDSL-Fork.

Füge die aktuelle QueryDSL-Bibliothek zur pom.xml hinzu. Das Beispiel verwendet folgende Versionseigenschaften:

<properties>
    <java.version>17</java.version>
    <kotlin.version>2.4.21</kotlin.version>
    <querydsl.version>5.1.0</querydsl.version>
    <openfeign.querydsl.version>7.7</openfeign.querydsl.version>
</properties>

Die QueryDSL-Abhängigkeit selbst sieht so aus:

<dependency>
    <groupId>io.github.openfeign.querydsl</groupId>
    <artifactId>querydsl-jpa</artifactId>
    <version>${openfeign.querydsl.version}</version>
</dependency>

Das Entity

Ich brauchte ein simples Entity welches ich zum Testen der Generierung der Q-Klassen von QueryDSL verwende. Dafür habe ich den Kotlin data-class Syntax verwendet um ein simples JPA kompatibles Entity mit wenig Zeilen zu erstellen.

import jakarta.persistence.Entity
import jakarta.persistence.GeneratedValue
import jakarta.persistence.Id

@Entity
data class TestEntity (
    val name: String,
    val exampleValue: Double
) {
        @Id @GeneratedValue
        val id: Int? = null
}

Das Repository

Spring Data bietet einfache Möglichkeiten zum Zugriff auf Datenbank-Entities via Repositories, die dann auch QueryDSL Support haben.

import com.felixzett.mmkqe.entity.TestEntity
import org.springframework.data.querydsl.QuerydslPredicateExecutor
import org.springframework.data.repository.CrudRepository

interface TestEntityRepository:
        CrudRepository<TestEntity, Int>,
        QuerydslPredicateExecutor<TestEntity>

Der QuerydslPredicateExecutor definiert welches Entity wir benutzen um unsere fortgeschrittenen Datenbankabfragen zu formulieren.

Die Konsumenten

Ich habe einen einfachen Service erstellt in welchen das Repository mit Dependency-Injection injiziert wird. Der Service wird nicht benutzt sondern dient dazu beim Kompilieren eine Verwendung der Q-Klassen zu generieren. Wenn die Q-Klassen zur Zeit des Kompilierens nicht generiert waren gibt es einen Fehler. Normalerweise würde erst der Test die Q-Klassen verwenden und es könnte sein dass die Q-Klassen-Generierung zwischen die compile und test-compile Maven-Phasen rutschen, das wiederum zurfolge hätte dass die Klassen zur normalen Kompilierzeit nicht zur Verfügung stehen.

import com.felixzett.mmkqe.entity.QTestEntity
import com.felixzett.mmkqe.entity.TestEntity
import com.felixzett.mmkqe.repository.TestEntityRepository
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.stereotype.Service

@Service
class TestEntityService @Autowired constructor(
        private val testEntityRepository: TestEntityRepository
){

    fun getTestEntityByName(name: String): TestEntity? {
        return testEntityRepository.findOne(
                QTestEntity.testEntity.name.eq(name)
        ).get()
    }
}

Zusätzlich habe ich einen Test erstellt der den QueryDSL Support auf einer H2-Datenbank testet.

import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest

@SpringBootTest
class TestEntityRepositoryTest {
    @Autowired
    private lateinit var testEntityRepository: TestEntityRepository

    @BeforeEach
    fun setup() {
        testEntityRepository.save(TestEntity("test", 8.0))
    }

    @Test
    fun test() {
        val testEntities = testEntityRepository.findAll()
        assertEquals(1, testEntities.count())
    }
}

Änderungen am Maven-Skript

Ich musste die Maven-Plugins so anpassen, dass der Kotlin Annotation Processor mit QueryDSL die Q-Klassen generiert bevor der Rest des Programms kompiliert wird.

<plugins>
    <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
    <plugin>
        <groupId>org.jetbrains.kotlin</groupId>
        <artifactId>kotlin-maven-plugin</artifactId>
        <configuration>
            <compilerPlugins>
                <plugin>jpa</plugin>
                <plugin>spring</plugin>
            </compilerPlugins>
            <args>
                <arg>-Xjsr305=strict</arg>
            </args>
            <jvmTarget>${java.version}</jvmTarget>
        </configuration>
        <executions>
            <execution>
                <id>compile</id>
                <phase>process-sources</phase>
                <goals>
                    <goal>compile</goal>
                </goals>
            </execution>
            <execution>
                <id>kapt</id>
                <phase>generate-sources</phase>
                <goals>
                    <goal>kapt</goal>
                </goals>
                <configuration>
                    <includeCompileClasspath>false</includeCompileClasspath>
                    <sourceDirs>
                        <sourceDir>src/main/kotlin</sourceDir>
                    </sourceDirs>
                    <annotationProcessorPaths>
                        <annotationProcessorPath>
                            <groupId>io.github.openfeign.querydsl</groupId>
                            <artifactId>querydsl-apt</artifactId>
                            <version>${openfeign.querydsl.version}</version>
                            <classifier>jpa</classifier>
                        </annotationProcessorPath>
                        <annotationProcessorPath>
                            <groupId>jakarta.persistence</groupId>
                            <artifactId>jakarta.persistence-api</artifactId>
                            <version>3.2.0</version>
                        </annotationProcessorPath>
                    </annotationProcessorPaths>
                </configuration>
            </execution>
            <execution>
                <id>test-compile</id>
                <phase>test-compile</phase>
                <goals>
                    <goal>test-compile</goal>
                </goals>
                <configuration>
                    <sourceDirs>
                        <sourceDir>src/test/kotlin</sourceDir>
                        <sourceDir>target/generated-sources/kapt/test</sourceDir>
                    </sourceDirs>
                </configuration>
            </execution>
        </executions>
        <dependencies>
            <dependency>
                <groupId>org.jetbrains.kotlin</groupId>
                <artifactId>kotlin-maven-noarg</artifactId>
                <version>${kotlin.version}</version>
            </dependency>
            <dependency>
                <groupId>org.jetbrains.kotlin</groupId>
                <artifactId>kotlin-maven-allopen</artifactId>
                <version>${kotlin.version}</version>
            </dependency>
        </dependencies>
    </plugin>
</plugins>

Das wars! Nach diesen Änderungen kann man QueryDSL mit Spring-Data-Repositories benutzen. Der Test sichert die Integration ab und bietet ein kleines Beispiel der Benutzung.