Vaadin 8 -> Binders nur mit Datentyp String?

[Zrebna]

Hi!

Scheinbar funktionieren binders bei Vaadin 8 nur mit dem Datentyp String.
Nun hat meine Klasse aber auch Attribute des Datentyps 'int' und 'boolean'.

public class Boxer {
    private String fullName;
    private String weightClass;
    private int numberOfFights;
    private String isActive;

Eine zweckentfremdende Möglichkeit wäre nun einfach alle Datentypen auf String setzen (wie bei isActive gemacht) und entsprechend Konstruktor und getters&setters anpassen. Das funktioniert zwar, aber finde ich nicht gut - User kann ja dann alles reinschreiben, was er will...

Sonst habe ich bzgl. Integers (bei booleans gibt es das wohl auch) noch die Möglichkeit mit 'withConverter()' zu arbeiten:

        binder.forField(numberOfFights)
        .withConverter(new StringToIntegerConverter("The number of fights must be a number!"))
        .bind(Boxer::getNumberOfFights, Boxer::setNumberOfFights);

Gefällt mir auch nicht, weil ich ja eigentlich via einem Validator z.B. bestimmen mag, dass die Anzahl der Kämpfe > 0 sein muss...,
d.h. falls Binders auch mit Integers funktionieren würden, dann könnte mein gewünschter Code wohl so aussehen:

    binder.forField(numberOfFights)
        .withValidator(number -> number > 0,
        "Boxer must have at least 1 fight!")
        .bind(Boxer::getNumberOfFights, Boxer::setNumberOfFights);

Das klappt eben nicht, weil wohl bei Binders nur Argumente das Datentyps String akzeptiert werden.

Daher frage ich mich, wie man hier am besten drumherumarbeiten kann, damit in Summe das rauskommt, was man haben will -> sprich Binders auch auf Attribute anderer Datentypen effektiv anwenden zu können? Kennt ihr da Möglichkeiten?

Zusatzfrage:
Interessehalber (möchte jedoch bei Vaadin 8 bleiben) : Kann man auf höheren Versionen von Vaadin mittlerweile Binders mit anderen Datentypen, als nur Strings
direkt benutzen?


Viele Grüße
Zrebna

 

[kneitzel]

Ich bin kein Vaadin Experte, da ich es mir nur mal testweise angesehen habe. Aber mein Verständnis ist hier doch, dass
a) das TextField nun einmal Text hat -> withConverter wird daher benötigt.
b) Du aber doch .withValidator und .withCOnverter zusammen nutzen kannst.

Etwas in der Art sollte also eigentlich funktionieren:

    binder.forField(numberOfFights)
        .withConverter(new StringToIntegerConverter("The number of fights must be a number!"))
        .withValidator(number -> number > 0, "Boxer must have at least 1 fight!")
        .bind(Boxer::getNumberOfFights, Boxer::setNumberOfFights);

Das ist eine Basis Funktionalität und da sollte sich zu 8 hoffentlich nicht zu viel geändert haben. v14 Doku zeigt das, was ich gesagt habe, z.B. unter:

Validating and Converting User Input | Binding Data to Components | Flow | Vaadin 14 Docs

Binder supports:

vaadin.com

Die Reihenfolge spielt da aber eine Rolle. Das erkennt man sehr schön an der Doku bei der mehrere Validatoren verwendet wurden. Da hat man halt beim Feld einen String -> erstes .Validator mit einem String.
Dann kommt der Converter -> Danach hat man ein Integer.
Der nächste Validator arbeitet daher mit dem Integer.

 

[Zrebna]

Danke schon mal für die Hilfe soweit und für den Link.
Im Link finde ich auch genau dein Vorgehen wieder und es macht auch absolut Sinn.
Es scheint aber so, dass man dafür höhere Versionen, als Vaadin 8 benötigt, denn bei Vaadin 8 wird gemeckert -> siehe Bild.
Attribut wurde in entsprechender Klasse auf 'int' gesetzt.
Es scheint so, dass in der untersten Zeile beim Referenzieren der Methoden der Boxer-Klasse mit dem Doppelpunkt-Operator wiederum Strings gebraucht werden? Jedoch gibt es bei Vaadin 8 keinen IntegerToStringConverter() und String.valueOf(number) geht an der Stelle wohl auch nicht.

 

[mrBrown]

Wie sehen denn Boxer#setNumberOfFights und Boxer#setNumberOfFights aus? Die beiden werden ja angemeckert

 

[Zrebna]

Also die getters und setters sehen so aus -> siehe Bild.
Oder meintest du das hier? -> siehe 2tes Bild.

 

[kneitzel]

Das passt gerade irgendwie nicht zu der Fehlermeldung. Denn er meckert ja an, dass getNumberOfFights vonBoxer einen String zurück gibt und dies nicht zu Integer passt.

Hast Du da evtl. noch einen nicht konsistenten Stand durch irgendwelche Tests oder durch probieren?

Und statt so Bildschirmausschnitten bitte die Klassen in CodeTags posten. Dabei dann ruhig uninteressante Teile weglassen, aber die class ... Zeile sowie die benötigten Felder / Methoden sollten sichtbar sein.

 

[Zrebna]

Hi!

Stimmt, sorry - weiß gar nicht, wieso ich gestern von Code-Snippets Screenshots gemacht habe, statt sie per Code-Tags zu posten.
Zu deinen Fragen, ich denke nicht, dass es hier noch Inkonsistenzen gab - also numberOfFights wurde als Datentyp 'int' eingestellt.

Mittlerweile habe ich noch eine andere Möglichkeit gefunden, wie man z.B. auch int-Variablen in Vaadin validieren kann.
Es soll wohl gehen, indem man eine 'javax validation'-dependency in die pom.xml hinzufügt und dan gewisste "Instruktions-Annotationen" vor die Variable schreibt - dies habe ich an einer Variable 'int years' getestet - leider klappt es in dem Sinne nicht, dass zwar ein Textfeld auf der webseite sichtbar ist (für 'years'), aber diese eben nicht validiert wird - mann kann quasi reinschreiben, was man will oder auch komplett leer lassen.
Hier mal der relevante Code-part dazu (bitte nicht wundern: Die Variable 'numberOfFights' habe ich hier bewusst auf String urückgesetzt, weil es mit 'int' nicht funktioniert und ich sehen wollte, wie es im localhost bzgl. 'years' aussieht)

Relevanter Code in der Klasse 'Boxer':

[B]import javax.validation.constraints.Max;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;[/B]

public class Boxer {
    private String fullName;
    private String weightClass;
    private String numberOfFights;
    private String isActive;
[B]    @NotNull
    @Min(value=16, message="The Boxer must be at least 16 years old!")
    @Max(value=65, message="The Boxer may not be older than 65 years old")
    private int years;[/B]

public int getYears() {
        return years;
    }

    public void setYears(int years) {
        this.years = years;
    }

Relevanter Code in der 'MyUI'-Klasse -> effektiv die 'Main':

        FormLayout formLayout = new FormLayout();
      
        TextField fullName = new TextField();
        TextField weightClass = new TextField();
        TextField numberOfFights = new TextField();
        TextField isActive = new TextField();
        [B]TextField years = new TextField();[/B]
      
        Binder<Boxer> binder = new Binder<>();
      
        binder.forField(fullName)
        .withValidator(name -> name.length() >= 5,
        "Full Name must contain at least 5 characters!")
        .bind(Boxer::getFullName, Boxer::setFullName);
      
        binder.forField(weightClass)
        .asRequired("Boxers must have a weight class!") // displayed message if the relevant text field is not filled
        .withValidator(weight -> weight.length() >= 2,
        "Weight Class name must contain at least 2 characters!")
        .bind(Boxer::getWeightClass, Boxer::setWeightClass);
          
        binder.forField(numberOfFights)
        .withValidator(fights -> fights.length() >= 1,
        "The number of Fights must contain at least 1 character!")
        .bind(Boxer::getNumberOfFights, Boxer::setNumberOfFights);
      
        binder.forField(isActive)
        .asRequired("The activity status of a Boxer must be known!")
        .withValidator(active -> active.length() >= 1,
        "The activity status of a boxer must be provided!")
        .bind(Boxer::isActive, Boxer::setActive); 
      
        Boxer newBoxer = new Boxer();
        binder.readBean(newBoxer);
      
        Button eventButton = new Button("Event Button",
                event -> {
                    try {
                        binder.writeBean(newBoxer);
                        Notification.show(newBoxer + "");
                        System.out.println(newBoxer);
                    } catch (ValidationException e) {
                        Notification.show("Boxer could not be validated!");
                    }
                });
              
        formLayout.addComponent(fullName);
        formLayout.addComponent(weightClass);
        formLayout.addComponent(numberOfFights);
        formLayout.addComponent(isActive);
        [B]formLayout.addComponent(years);[/B]
        formLayout.addComponent(eventButton);

    customPanel.setContent(formLayout);
      
    gridLayout.addComponent(customPanel);

    setContent(gridLayout);

Ok, ich stoppe nun hier, weil der Post sonst zu lange wird.
Wie gesagt, bzgl. der Variable numberOfFights und dem Vorgehen mittels Binders zu validieren ist es so gewesen:
- Noch keine 'years'-Variable
- Datentyp von numberOfFights ist ein Integer (also 'int') gewesen (getters, setters und Konstruktor entsprechend angepasst) - dies wurde auch
in der MyUI-Klasse an erforderlichen Stellen adjustet.
- Dein Codevorschlag wurd 1:1 übernommen und versucht.

Wenn du willst, dann poste ich in einem gesondertem Post nochmal den relvanten Code dazu, aber evtl. erst wenn das gegenwärtige Problem (warum klappt das alternative Vaolidationsvorgehen nicht) gelöst ist, damit es nicht zu viel auf einmal und zu wirr wird.

PS und offtopic:
Ich wollte die aller-relevantesten Zeiel für Euch via 'bolding' nochmal extra hervorheben - scheinbar geht das nicht.
Gibt es sonst noch Möglichkeiten bestimmte Zeilen innerhalb den Code-Tags extra hervorzuheben, damit die Lesbarkeit erleichtet wird?

 

[kneitzel]

Was spricht eigentlich dagegen, eine aktuelle Version von Vaadin zu verwenden? Die aktuelle LTS Version ist 14, non LTS sogar schon 21.

Bei einer 8er Version werden wir nicht mal eben auf start.vaadin.com ein Projekt erstellen können um sowas auszutesten. Also auf Vaadin 8 zu bestehen ist aktuell aus meiner Sicht nicht ratsam oder für mich verständlich.

Irgendwas im falschen Typ darzustellen würde ich generell ablehnen. Maximal wäre da eine Idee, Lösungen zu bauen wie:

int numberOfFights;
public int getNumberOfFights() { return numberOfFights; }
public void setNumberOfFights(int numberOfFights) { this.numberOfFights = numberOfFights; }

public String getNumberOfFightsAsString() { return "" + numberOfFights; }
public void setNumberOfFightsAsString(String numberOfFightsString) { numberOfFights = Integer.parseInt(numberOfFightsString); }
public static boolean isNumberOfFightsStringValid(String numberOfFightsString) {
    // Parsen und prüfen...
}

Da habe ich zwar immer noch kein gutes Gefühl, aber ich habe jetzt eine Möglichkeit, das direkt einzubinden und der Datentyp bleibt korrekt:

        binder.forField(numberOfFights)
        .withValidator(fights -> Boxer::isNumberOfFightsStringValid(fights()), "The number of Fights must be a Number greater zero!")
        .bind(Boxer::getNumberOfFightsAsString, Boxer::setNumberOfFightsAsString);

Aber die Frage ist immer noch, wieso sowas notwendig ist. Mag sein, dass Vaadin 8 da ein Problem hat - dann wäre es aber um so wichtiger, diese alte Version nicht mehr zu nutzen und endlich zu wechseln.

Und diese Validation, die Du gefunden hast, dürfte JSR 380 sein. Diese Annotations alleine machen erst einmal für sich nichts. Das ist einfach nur wie ein Aufkleber. Nur weil Du ein Aufkleber "Diesel" beim Tankdeckel aufklebst,kann man da dennoch beliebige Dinge rein packen und du merkst es erst einmal nicht.
Was Du dann brauchst, ist ein Validator, der das dann prüft. Das bedeutet also: Du brauchst einen Prüfer der etwas prüfst: Du tankst also Benzin statt Diesel. Wenn Du fertig bist mit Tanken kommt der Prüfer und prüft Dein Auto und dann bekommst Du eine Liste mit gefundenen Dingen und da steht dann: Im Tank ist kein Diesel!
==> a) Validator wird benötigt
==> b) Es wird dann der Bean in seinem aktuellen (ggf. nicht validen) Zustand geprüft.

Es gibt Frameworks, die das dann direkt integriert haben. Vaadin scheint hier bei Formularen aber einen anderen Weg zu nehmen. Daher ist das erst einmal nicht der Weg, den ich gehen würde.

 

[Zrebna]

Hi!

Bzgl. warum Vaadin 8 und nicht neueste Version:
Ich lerne gerade u.a. Vaadin im Rahmen eines Moduls und dort wird die 8er Version verwendet -> folglich will ich logischerweise lernen genau mit dieser Version umgehen zu können.

Ansonsten aber danke für deine Lösungsidee - ist zwar ein Umweg, aber gefällt mir unter den Umständen (ältere Version) eigentlich ganz gut und sollte funktionieren 👍

Ansonsten auch Danke für alle weiteren Erklärungen

 

[Zrebna]

Update:
Habe es gerade mit deiner Idee versucht, aber es klappt noch nicht...
Erste Frage ist, was ist das 'fights()' als übergebener Parameter in Zeile 2 bei deinem 2tem Codesnippet?
Ich hätte da einfach als Parameter übergeben: numberOfFights.getValue() -> wir wollen ja das das holen, was der User eingibt und in einen Integer parsen? Bzw. einfach die Klammern bei fights() weglassen, also 'ifghts', weil ja mittels lambda Expr. glaub ich 'fights' bereits als Userinput erkannt wird.
Das funktioniert aber auch nicht btw...

Ich poste mal die gesamte Klasse Boxer hier als Code und relevanten Codeauszug aus der "Main" - evtl. habe ich irgendwo einen Fehler gemacht...Die Funktion setNumberOfFightsAsString() habe ich leicht umbenannt, weil es für mich dann mehr Sinn bzgl. der Aufgabe der Methode macht (sie soll ja nen String in ein Integer konvertieren und den Wert der int-Variable numberOfFights zuweisen...?)

Klasse Boxer:

public class Boxer {
    private String fullName;
    private String weightClass;
    private int numberOfFights;
    private String isActive;
    @NotNull
    @Min(value=16, message="The Boxer must be at least 16 years old!")
    @Max(value=65, message="The Boxer may not be older than 65 years old")
    private int years;
   
    // default constructor
    public Boxer () {
        super();
    }
   
    // constructor with fields
    public Boxer(String fullName, String weightClass, int numberOfFights, String isActive) {
        super();
        this.fullName = fullName;
        this.weightClass = weightClass;
        this.numberOfFights = numberOfFights;
        this.isActive = isActive;
    }
   
    // toString-Method
    @Override
    public String toString() {
        return "Boxer [fullName=" + fullName + ", weightClass=" + weightClass + ", numberOfFights=" + numberOfFights
                + ", isActive=" + isActive + "]";
    }
   
    // helper methods
   
    public String getNumberOfFightsAsString() {
        return "" + numberOfFights;
    }
   
    public void setNumberOfFightsFromStringToInteger(String numberOfFightsString) {
        numberOfFights = Integer.parseInt(numberOfFightsString);
    }
    public boolean isNumberOfFightsStringValid(String numberOfFightsString) {
        return Integer.parseInt(numberOfFightsString) > 0;
    }
       
    // getters & setters

    public String getFullName() {
        return fullName;
    }

    public void setFullName(String fullName) {
        this.fullName = fullName;
    }

    public String getWeightClass() {
        return weightClass;
    }

    public void setWeightClass(String weightClass) {
        this.weightClass = weightClass;
    }

    public int getNumberOfFights() {
        return numberOfFights;
    }

    public void setNumberOfFights(int numberOfFights) {
        this.numberOfFights = numberOfFights;
    }

    public String isActive() {
        return isActive;
    }

    public void setActive(String isActive) {
        this.isActive = isActive;
    }

    public int getYears() {
        return years;
    }

    public void setYears(int years) {
        this.years = years;
    }
}

Relevanter Coder in "Main"-Klasse:

TextField numberOfFights = new TextField();
    // ...

    binder.forField(numberOfFights)
        .withValidator(fights -> Boxer::isNumberOfFightsStringValid(fights()), "The Boxer must have at least 1 fight!")
   /* 
     ----------------------------  Fehlermeldungen: ------------------------------------------------------------------------------
Multiple markers at this line
    - The type of getNumberOfFights() from the type Boxer is int, this is incompatible with the descriptor's return type: String
    - The method bind(ValueProvider<Boxer,String>, Setter<Boxer,String>) in the type Binder.BindingBuilder<Boxer,String> is not applicable for         the arguments (Boxer::getNumberOfFights, Boxer::setNumberOfFights)
    - Syntax error on token(s), misplaced construct(s)
  */
        .bind(Boxer::getNumberOfFightsAsString, Boxer::setNumberOfFightsFromStringToInteger);
   /* 
     ----------------------------  Fehlermeldungen: ------------------------------------------------------------------------------
   The type Boxer does not define setNumberOfFights(Boxer, String) that is applicable here
*/

 

[kneitzel]

Das ist ein Lambda Ausdruck. withValidator erwartet da ein Predicate. Der Aufbau ist halt:
binder ist ein Binder.
mit dem .forField(...) bekommt du ein Binder.BindingBuilder<BEAN, TARGET> und das TARGET hängt vom Typ des Controls ab. TextField ist ein HasValue<String> daher ist TARGET eben String.

Wieso das so nicht funktioniert und wieso diese Meldung kommt, kann ich nicht sagen. Denn da ist ja jetzt gar kein getNumberOfFights() mehr. Daher würde ich jetzt fast vermuten, dass Du da das Projekt nicht richtig baust oder so. Aber da ich das hier nicht einmal testweise nachstellen kann, kann ich dazu nichts näheres sagen.

 

[Zrebna]

Das ist ein Lambda Ausdruck. withValidator erwartet da ein Predicate. Der Aufbau ist halt:
binder ist ein Binder.
mit dem .forField(...) bekommt du ein Binder.BindingBuilder<BEAN, TARGET> und das TARGET hängt vom Typ des Controls ab. TextField ist ein HasValue<String> daher ist TARGET eben String.

Wieso das so nicht funktioniert und wieso diese Meldung kommt, kann ich nicht sagen. Denn da ist ja jetzt gar kein getNumberOfFights() mehr. Daher würde ich jetzt fast vermuten, dass Du da das Projekt nicht richtig baust oder so. Aber da ich das hier nicht einmal testweise nachstellen kann, kann ich dazu nichts näheres sagen.

Vorweg, ich muss mich entschuldigen - ich habe vorher das Projekt nach den Änderungen wohl nicht gespeichert...denn nun sind alle Fehlermeldungen verschwunden, außer eine Syntax-Fehlermeldung, die ich nicht lösen kann:

        binder.forField(numberOfFights)
        .withValidator(fights -> Boxer::isNumberOfFightsStringValid(fights()),"The Boxer must have at least 1 fight!")
            // Fehlermeldung: Syntax error on token(s), misplaced construct(s)
        .bind(Boxer::getNumberOfFightsAsString, Boxer::setNumberOfFightsFromStringToInteger);

Danke auch für die Erklärungen bzgl. wie ein Binder funktioniert
Ich frage mich nur noch, ob es denn nicht einfach nur 'fights', statt 'fights()' heißen müsste - als übergebendes Argument in Zeile 2 von deinem zweitem Codesnippet? Gleiche Syntax-Fehlermeldung bleibt aber auch dann bestehen...

Evtl. habe ich tatsächlich das Projekt irgendwo falsch gebaut, aber das können wir eben von hier aus nicht prüfen bzw. du nicht...
Es ist auch nicht soooo wichtig....Danke auf jeden Fall für den Austausch - habe auf jeden Fall wieder ein, zwei neue Dinge gelernt 👍

 

[kneitzel]

Ich frage mich nur noch, ob es denn nicht einfach nur 'fights', statt 'fights()' heißen müsste

Ganz genau! Die Klammern sind da falsch und dürfen da nicht hin.

Was dem Fehler angeht: Evtl. einmal die ganze Klasse zeigen. Vielleicht kannst Du ja auch einfach mal ein clean laufen lassen und das ganze Projekt als ZIP bereit stellen (so es nicht sehr viel größer ist) um das einmal selbst zu sehen?

 

[Zrebna]

Alles klar und ja gerne^^
Ich weiß nicht, wie das mit 'clean laufen lassen" gemeint ist bzw. weiß einfach nicht, was das ist / wie das geht.
Das Projekt hab ich mal gezippt (ca. 120 KB groß).
Es ist einfach so ein Einsteigerprojekt innerhalb einem Udemy-Kurs, den ich gerade als Vorbereitung für ein Modul mache...daher ist das recht wirr - ich denke, dass es ab Zeile 240 in der Klasse 'MyUI' für diesen Thread relevant wird.
Ich stelle die Zip einfach mal hier rein...

 

[kneitzel]

Das wäre dann ein ausführen des Maven Ziels clean. In IntelliJ kann man das im Maven Fenster auswählenund mit Doppelklick starten. Bei anderen IDEs wird es ähnlich gehen.

Ansonsten die Fehler in Deinem Code:
- Ich habe da die Lambda Expression natürlich falsch angeben. Das "::" muss natürlich ein "." sein. Es soll ja eine Methode aufgerufen werden. Mit :: gibt man eine Methoden-Referenz an, aber dann darf da natürlich keine Klammer mehr folgen mit einem Parameter. Das sieht man im bind.
- Die Methode isNumberOfFightsStringValid muss static sein
- Die Methode setNumberOfFightsAsString fehlte (bzw. hiess setNumberOfFightsFromStringToInteger bei Dir)

    public String getNumberOfFightsAsString() {
        return "" + numberOfFights;
    }

    public void setNumberOfFightsAsString(String value) {
        numberOfFights = Integer.parseInt(value);
    }

    public static boolean isNumberOfFightsStringValid(String numberOfFightsString) {
        return Integer.parseInt(numberOfFightsString) > 0;
    }

        binder.forField(numberOfFights)
        .withValidator(fights -> Boxer.isNumberOfFightsStringValid(fights), "The number of Fights must be a Number greater zero!")
        .bind(Boxer::getNumberOfFightsAsString, Boxer::setNumberOfFightsAsString);

 

[kneitzel]

Und ganz nebenbei:

        binder.forField(numberOfFights)
                .withConverter(new StringToIntegerConverter("The number of fights must be a number greater zero!"))
                .withValidator(number -> number > 0, "Boxer must have at least 1 fight!")
                .bind(Boxer::getNumberOfFights, Boxer::setNumberOfFights);

liess sich bei mir problemlos übersetzen. Starten konnte ich das Projekt nicht - das Projekt liess sich über das Vaadin Plugin nicht starten, weil da irgendwas nicht gesetzt war und das war File extra deployen war mir jetzt zu viel Arbeit.

 

[Zrebna]

Ah, super - hat nun geklappt
Vielen Dank für die Hilfe und die Erklärungen dazu 👍