Il modulo del metodo (Classe <T>) dalla classe Form è obsoleto in Play! Framework

Question

Ho passato molto tempo a provare così a risolvere questo problema ea cercare il metodo per sostituire questo, senza successo.

Innanzitutto, gioca! mi obbliga a usare e iniettare FormFactory (che è spiegato in https://www.playframework.com/documentation/2.5.0/JavaForms).

Ma solo per istanziare questo FormFactory ho dovuto passare 3 parametri per il suo costruttore, ovvero MessagesApi, Formatters e Validator. Includendo, ho dovuto istanziare l'interfaccia del Validator e non sono sicuro che sia il modo giusto per farlo.

Per rendere più facile, ho separato in un'altra classe:

package controllers; 

    import java.util.Set; 
    import javax.validation.ConstraintViolation; 
    import javax.validation.Validator; 
    import javax.validation.executable.ExecutableValidator; 
    import javax.validation.metadata.BeanDescriptor; 
    import play.data.FormFactory; 
    import play.data.format.Formatters; 
    import play.i18n.MessagesApi; 

    class Validador implements Validator { 

    @Override 
    public ExecutableValidator forExecutables() { 
     // TODO Auto-generated method stub 
     return null; 
    } 

    @Override 
    public BeanDescriptor getConstraintsForClass(Class<?> arg0) { 
     // TODO Auto-generated method stub 
     return null; 
    } 

    @Override 
    public <T> T unwrap(Class<T> arg0) { 
     // TODO Auto-generated method stub 
     return null; 
    } 

    @Override 
    public <T> Set<ConstraintViolation<T>> validate(T arg0, Class<?>... arg1) { 
     // TODO Auto-generated method stub 
     return null; 
    } 

    @Override 
    public <T> Set<ConstraintViolation<T>> validateProperty(T arg0, String arg1, Class<?>... arg2) { 
     // TODO Auto-generated method stub 
     return null; 
    } 

    @Override 
    public <T> Set<ConstraintViolation<T>> validateValue(Class<T> arg0, String arg1, Object arg2, Class<?>... arg3) { 
     // TODO Auto-generated method stub 
     return null; 
    } 
} 

public class FormCreator { 

    MessagesApi msgAPI; 
    Formatters formatador; 
    Validador validador; 
    FormFactory factory; 

    public FormCreator() { 
     msgAPI = new MessagesApi(null); 
     formatador = new Formatters(msgAPI); 
     validador = new Validador(); 
     factory = new FormFactory(msgAPI, formatador, validador); 
    } 


    // getters e setters 
    public MessagesApi getmsgAPI() { 
     return msgAPI; 
    } 
    public void setmsgAPI(MessagesApi msgAPI) { 
     this.msgAPI = msgAPI; 
    } 
    public Formatters getFormatador() { 
     return formatador; 
    } 
    public void setFormatador(Formatters formatador) { 
     this.formatador = formatador; 
    } 
    public Validador getValidador() { 
     return validador; 
    } 
    public void setValidador(Validador validador) { 
     this.validador = validador; 
    } 
    public FormFactory getFactory() { 
     return factory; 
    } 
    public void setFactory(FormFactory factory) { 
     this.factory = factory; 
    } 
} 

E nel mio controller devo mettere qualcosa di simile:

@Inject 
FormCreator formCreator = new FormCreator(); 

althrough che ho trascorso alcune ore per scopri questo, questa domanda è stata risolta.

Un altro è, qualunque cosa faccia, il metodo bindFromRequest() restituisce sempre null, e non è perché l'eclissi, e qualsiasi altra cosa, è perché la chiamo da un modulo creato da questa fabbrica.

Esempio:

// never works 
formCreator.getFactory().form(Diretor.class).bindFromRequest(); 

// works fine, but is deprecated 
Form.form(Diretor.class).bindFromRequest(); 

Qual è il metodo più recente da utilizzare al posto di questo metodo obsoleto?

Grazie in anticipo.

Answer 1

La documentazione Giocare 2.5.x afferma che:

Per eseguire il wrapping di una classe è necessario iniettare un file play.data.FormFactory nel controller che consente quindi di creare il modulo:

Form userForm = formFactory.form (User.class);

Quindi il primo passaggio consiste nell'iniettare FormFactory nel controller. Lo si fa in questo modo:

package controllers; 

import play.*; 
import play.mvc.*; 

public class Application extends Controller { 

    @Inject FormFactory formFactory; 

    ... 
} 

Poi nell'azione in cui si gestisce il modulo di richiesta-presentazione è possibile utilizzare il FormFactory come questo:

public Result handleFormSubmission() { 
    formFactory.form(Director.class).bindFromRequest(); 
} 

Answer 2

non si dispone di inizializzare il FormFactory, provare quanto segue:

@Inject FormFactory formFactory; 

e poi nella vostra azione, chiamare:

formFactory.form(Director.class).bindFromRequest(); 

Answer 3

Purtroppo, la risposta di cui sopra non ha funzionato per me . Ecco cosa mi è venuto in mente e funziona per il mio progetto.

import play.mvc.*; 
import play.*; 
import views.html.logins.*; 
import models.User; 
import play.data.Form; 
import play.data.FormFactory; 
import javax.inject.Inject; 

public class Login extends Controller{ 
    private static Form<User> loginForm; 

    @Inject 
    public Login(FormFactory formFactory) { 
     this.loginForm = formFactory.form(User.class); 
    } 

    public Result list() { 
     return TODO; 
    } 
} 

Answer 4

public class UserController extends Controller { 

@Inject 
FormFactory formFactory; 

public Result loginProcess(){ 

    Form<LoginForm> loginForm = formFactory.form(LoginForm.class).bindFromRequest(); 

    ... 
    } 
} 

non avete bisogno che il costruttore Accesso lì ..guarda il mio esempio