Daten-Transformation mit Kotlin-Extensions

von Peter Soth

In diesem kurzen Blog-Post möchte ich über eine äußerst interessante Funktionalität - Extension genannt - der Programmiersprache Kotlin schreiben. Mit Extensions kann man innerhalb von Kotlin eine Klasse erweitern, ohne von dieser erben oder das sogenannte Decorator-Pattern einsetzen zu müssen.

Anwendungsbeispiel:

In meinem Beispiel geht es um darum, das PIM-System, das wir für einen unserer Pharma-Kunden ständig weiterentwickeln, um eine Such-Funktionalität zu erweitern.

Für diese Such-Funktionalität werden Informationen wie Präparatenamen, PZN, Indikation, Darreichungsform, etc. aus der Datenbank ausgelesen, in ein JSON transformiert und schließlich in der Suchmaschine indiziert.

Wir benutzen: MySQL, JOOQ (Light-Datenbank-Mapping-Softwarebibliothek), Spring Boot, Kotlin und OpenSearch. JOOQ wird hier aus Performance-Gründen als Ersatz für Hibernate eingesetzt. JOOQ generiert aus den Datenbank-Tabellen POJOs. In der Suchmaschine wollen wir jedoch nicht alle Spalten der Datenbank indizieren, sondern nur einen Teil davon. Für diese Daten-Transformation setzen wir die Extensions von Kotlin ein.

Der Sourcecode unten zeigt die Kotlin-Extension-Funktion mit dem Namen .toProductDataSearchable(). Diese erweitert die Klasse DdbProductdata, die ein von JOOQ generiertes POJO ist. Die Klasse ProductDataSearchable ist wiederum eine Kotlin-Data-Klasse, die nur einen Teil der Datenbankspalten enthält und für die Generierung des JSON Objekts benötigt wird. Dieses dient wiederum zur Indizierung der Suchmaschine OpenSearch.

private fun DdbProductdata.toProductDataSearchable() = ProductDataSearchable(
        ...
        productName = productname,
        otherComponents = otherComponents,
        activeComponents = activeComponents,
        indications = masterDataService.getIndications(id),
        dosageForm = dosageFormDescription,
        licenseNumber = licenseNumber
        ...
)

data class ProductDataSearchable(
    ...
    val productName: String,
    val otherComponents: String?,
    val activeComponents: String?,
    val indications: String?,
    val dosageForm: String,
    val licenseNumber: String
    ...
)

Und folgender Sourcecode zeigt eine Datenbank-Abfrage mithilfe von JOOQ. Interessanterweise sei hier noch erwähnt, dass die Map Map<ProductDataSearchable, List<ProductPacksSearchable>> eine 1:n Relation abbildet. Die Datentransformation findet zum Schluss in fetchGroups durch r -> r.into(DDB_PRODUCTDATA).into(DdbProductdata::class.java).toProductDataSearchable() statt. Hierbei wird zunächst die POJO Klasse DdbProductdata mittels JOOQ befüllt und dann mit der Extensions-Funktion .toProductDataSearchable() transformiert.

private fun getAllProductData(
        branchId: Long?,
        legalEntityId: Long?
    ): Map<ProductDataSearchable, List<ProductPacksSearchable>> {
        return context
            .select()
            .from(DDB_PRODUCTDATA)
            .join(DDB_PRODUCTPACKS)
            .on(DDB_PRODUCTPACKS.PRODUCT_DATA_ID.eq(DDB_PRODUCTDATA.ID))
            .join(DDB_PRODPACK_LE)
            .on(DDB_PRODPACK_LE.PRODUCTPACKS_ID.eq(DDB_PRODUCTPACKS.ID))
            .join(COM_LEGALENTITY)
            .on(COM_LEGALENTITY.ID.eq(DDB_PRODPACK_LE.LEGAL_ENTITY_ID))
            .where(DDB_PRODUCTDATA.BRANCH_ID.eq(branchId))
            .and(COM_LEGALENTITY.ID.eq(legalEntityId))
            .orderBy(DDB_PRODUCTDATA.PRODUCTNAME.asc())
            .fetchGroups(
                { r -> r.into(DDB_PRODUCTDATA).into(DdbProductdata::class.java).toProductDataSearchable() },
                { r -> r.into(DDB_PRODUCTPACKS).into(DdbProductpacks::class.java).toProductPacksSearchable() }
            )
    }

Fazit

Die Extensions-Funktionen von Kotlin kann man vielfältig einsetzen. In meinem Beispiel wurden sie benutzt, um Daten zu transformieren. Der hierbei entstandene Code ist im Vergleich zu Java sehr viel übersichtlicher und einfacher nachzuvollziehen.

Links