Passer au contenu principal

DSL Kotlin pour webforJ

Aperçu

Écrivez-le en Kotlin. Gardez votre Java.

Le Kotlin DSL permet de créer des interfaces webforJ avec une syntaxe concise et sûre du point de vue des types. Au lieu d’utiliser des appels impératifs, vous écrivez du code déclaratif qui décrit l’écran et qui se compile dans le même projet que votre code Java.

Ajouter à un projetAvec le DSL

La classe que vous connaissez, en version builder

  • Buttondevientbutton()
  • TextFielddevienttextField()
  • FlexLayoutdevientflexLayout()
  • Breakdevient`break`()

Les boutons, champs, mises en page, boîtes de dialogue, tiroirs, listes et éléments HTML en ont chacun un, nommé d’après la classe en camelCase.

Même écran, deux langues

Lisez le Java. Lisez ensuite le Kotlin.

Les deux côtés construisent les mêmes composants avec les mêmes classes webforJ. Côté Kotlin, les setters et les appels à add() disparaissent : les composants s’imbriquent et la configuration se fait dans des blocs.

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)
        }
      }
    }
  }
}

Ce que le DSL vous offre

Constructeurs, blocs et les lambdas

Chaque fonction de construction crée un composant, l’ajoute à son conteneur parent et exécute un bloc de configuration. Le reste du DSL en découle.

Blocs de configuration

Le bloc reçoit le composant sous forme de this ; vous pouvez donc définir ses propriétés et appeler directement ses méthodes.

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

  • Builders nommés d’après les composants

    Chaque composant possède une fonction nommée d’après sa classe en camelCase. La plupart acceptent, avant le bloc, les options que vous définissez le plus souvent, comme un libellé ou un texte indicatif.

  • Blocs imbriqués

    Les composants qui contiennent des éléments enfants acceptent des appels DSL imbriqués dans leur bloc, de sorte que le code reflète la structure de l’écran.

  • Événements sous forme de lambdas

    Les écouteurs utilisent des méthodes préfixées par on qui acceptent une lambda, comme onClick et onModify.

  • Sécurité de la portée

    Les enfants ne sont insérés que dans les composants qui les prennent en charge. Un ajout accidentel dans une portée externe ne compile pas.

  • Styles et noms de classes

    La propriété styles permet d’accéder aux propriétés CSS avec des crochets, comme setStyle() en Java. Les noms de classe s’ajoutent avec +=.

  • À côté de votre code Java

    Kotlin se compile en bytecode JVM. Utilisez des composants composites Kotlin depuis des classes Java et imbriquez des composants Java dans des blocs DSL avec add().

Étendre le DSL

Vos propres composants, en tant que constructeurs également

Les composants personnalisés et les bibliothèques tierces s’intègrent au DSL via une fonction d’extension sur HasComponents. L’utilitaire init ajoute le composant à son parent, exécute le bloc et le renvoie. Les composants composites créés avec le DSL obtiennent une fonction de la même manière.

StarRating.kt
fun @WebforjDsl HasComponents.starRating(
  block: @WebforjDsl StarRating.() -> Unit = {}
): StarRating {
  return init(StarRating(), block)
}
Étendre le DSL dans la documentation

Comment démarrer

Ajouter Kotlin vers un projet Maven

Le DSL Kotlin est disponible à partir de webforJ 25.12. Un projet qui se compile déjà avec Maven nécessite une dépendance et un plugin.

  1. 1

    Ajouter les dépendances

    Ajoutez le module DSL Kotlin de webforJ et la bibliothèque standard Kotlin à votre pom.xml.

  2. 2

    Ajouter le plugin Maven Kotlin

    Compile vos sources Kotlin et Java en une seule fois. Aucune installation séparée de Kotlin n’est nécessaire.

  3. 3

    Utilisez Kotlin aux côtés de Java.

    Les fichiers Kotlin peuvent se trouver dans leur propre dossier source ou dans le même dossier que vos fichiers Java.

  4. 4

    Écrire une vue et compiler

    Créez une vue à l’aide des builders. Maven compile ensuite votre code Kotlin avec votre code Java.

Configurer le DSL KotlinUtilisation du DSL