Overslaan naar hoofdinhoud

Kotlin DSL voor webforJ

Voorbeeld

Schrijf het in Kotlin. Behoud je Java.

De Kotlin DSL bouwt webforJ-interfaces met beknopte, typeveilige syntaxis. In plaats van imperatieve aanroepen schrijf je declaratieve code die leest als een beschrijving van het scherm en in hetzelfde project als je Java wordt gecompileerd.

Voeg het toe aan een project Met de DSL

De klasse die je kent, als builder

  • Buttonwordtbutton()
  • TextFieldwordttextField()
  • FlexLayoutwordtflexLayout()
  • Breakwordt`break`()

Knoppen, velden, lay-outs, dialoogvensters, zijpanelen, lijsten en HTML-elementen hebben elk één, genoemd naar de klasse in camelCase.

Hetzelfde scherm, twee talen

Lees Java. Lees daarna de Kotlin.

Beide kanten bouwen dezelfde componenten met dezelfde webforJ-klassen. Aan de Kotlin-kant vervallen de setters en add()-aanroepen: componenten worden in elkaar genest en configuratie gebeurt in blokken.

JavaHelloView.java

@Route("/hello")
public class HelloView extends Composite<FlexLayout> {
  private final FlexLayout self = getBoundComponent();
  private TextField name = new TextField("What is your name?");
  private Button greet = new Button("Say hello");

  public HelloView() {
    greet.setTheme(ButtonTheme.PRIMARY)
        .addClickListener(e ->
            Toast.show("Welcome, " + name.getValue() + "!",
                Theme.SUCCESS));
    self.add(name, greet);
  }
}

KotlinHelloView.kt

@Route("hello")
class HelloView : Composite<FlexLayout>() {
  private val self = boundComponent

  init {
    self.apply {
      val name = textField("What is your name?")
      button("Say hello") {
        theme = ButtonTheme.PRIMARY
        onClick {
          Toast.show("Welcome, ${name.text}!", Theme.SUCCESS)
        }
      }
    }
  }
}

Wat de DSL je biedt

Bouwers, blokken en lambda’s

Elke builderfunctie maakt een component, voegt het toe aan de bovenliggende container en voert een configuratieblok uit. De rest van de DSL volgt daaruit.

Configuratieblokken

Het blok ontvangt de component als this, zodat je de eigenschappen ervan instelt en de methoden rechtstreeks aanroept.

textField("Email") {
  placeholder = "you@example.com"   // this.placeholder
  required = true                   // this.required
  onModify { validate() }           // this.onModify(...)
}

  • Builders vernoemd naar componenten

    Elk component heeft een functie met de naam van de klasse in camelCase. De meeste accepteren vóór het blok de opties die je het vaakst instelt, zoals een label of placeholder.

  • Geneste blokken

    Componenten met onderliggende componenten accepteren geneste DSL-aanroepen binnen hun blok, zodat de code de structuur van het scherm volgt.

  • Gebeurtenissen als lambda's

    Listeners gebruiken methoden met het voorvoegsel on die een lambda accepteren, zoals onClick en onModify.

  • Scopeveiligheid

    Kind-elementen kunnen alleen worden toegevoegd aan componenten die deze ondersteunen. Per ongeluk toevoegen aan een buitenste scope leidt tot een compileerfout.

  • Stijlen en klassennamen

    De eigenschap styles biedt toegang tot CSS-eigenschappen via blokhaken, net als setStyle() in Java. Klassenamen voeg je toe met +=.

  • Naast je Java-code

    Kotlin wordt gecompileerd naar JVM-bytecode. Gebruik Kotlin-composities vanuit Java-klassen en nest Java-componenten in DSL-blokken met add().

De DSL uitbreiden

Je eigen componenten, ook als bouwers

Aangepaste componenten en bibliotheken van derden worden via een uitbreidingsfunctie op HasComponents aan de DSL toegevoegd. De helper init voegt de component toe aan het bovenliggende element, voert het blok uit en retourneert de component. Samengestelde componenten die je met de DSL bouwt, krijgen op dezelfde manier een functie.

StarRating.kt
fun @WebforjDsl HasComponents.starRating(
  block: @WebforjDsl StarRating.() -> Unit = {}
): StarRating {
  return init(StarRating(), block)
}
De DSL in de documentatie uitbreiden

Aan de slag

Kotlin toevoegen naar een Maven-project

De Kotlin DSL is beschikbaar vanaf webforJ 25.12. Een project dat al met Maven wordt gebouwd, heeft een afhankelijkheid en een plug-in nodig.

  1. 1

    Afhankelijkheden toevoegen

    Voeg de webforJ Kotlin DSL-module en de Kotlin-standaardbibliotheek toe aan je pom.xml.

  2. 2

    Voeg de Kotlin Maven-plugin toe

    Het compileert je Kotlin- en Java-broncode in één build. Een aparte Kotlin-installatie is niet nodig.

  3. 3

    Zet Kotlin naast je Java

    Kotlin-bestanden kunnen in hun eigen bronmap staan of in dezelfde map als je Java-bestanden.

  4. 4

    Schrijf een view en compileer

    Schrijf een view met de builders. Maven compileert daarna je Kotlin naast je Java-code.

Kotlin DSL instellenDe DSL gebruiken