O que é @ModelAttribute em Spring MVC?
https://stackoverflow.com/questions/3423262
-
26-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Qual é o propósito e o uso de @ModelAttribute no Spring MVC?
Solução
@ModelAttribute refere -se a uma propriedade do objeto modelo (o M no MVC;), digamos que temos um formulário com um objeto de apoio de formulário que é chamado de "pessoa", então você pode fazer com que o MVC da mola forneça esse objeto para um método do controlador usando o @ModelAttribute anotação:
public String processForm(@ModelAttribute("person") Person person){
person.getStuff();
}
Por outro lado, a anotação é usada para definir objetos que devem fazer parte de um modelo. Portanto, se você deseja ter um objeto de pessoa referenciado no modelo, você pode usar o seguinte método:
@ModelAttribute("person")
public Person getPerson(){
return new Person();
}
Esse método anotado permitirá o acesso ao objeto de pessoa em sua opinião, pois ele é adicionado automaticamente aos modelos na primavera.
Outras dicas
Eu sei que este é um fio antigo, mas pensei em jogar meu chapéu no ringue e ver se consigo enlamear a água um pouco mais :)
Eu encontrei minha luta inicial para entender @ModelAttribute foi resultado da decisão da primavera de combinar várias anotações em uma. Ficou mais claro quando dividi em várias anotações menores:
Para anotações de parâmetros, pense em @ModelAttribute como o equivalente a @Autowired + @Qualifier ou seja, tenta recuperar um feijão com o nome dado do modelo gerenciado da primavera. Se o bean nomeado não for encontrado, em vez de jogar um erro ou retornar null, isso implicitamente assume o papel de @Bean ou seja, crie uma nova instância usando o construtor padrão e adicione o feijão ao modelo.
Para anotações de método, pense em @ModelAttribute como o equivalente a @Bean + @Before, ou seja, ele coloca o feijão construído pelo código do usuário no modelo e é sempre chamado antes de um método de manuseio de solicitação.
Figurativamente, eu vejo @ModelAttribute como o seguinte (por favor, não leve literalmente !!):
@Bean("person")
@Before
public Person createPerson(){
return new Person();
}
@RequestMapping(...)
public xxx handlePersonRequest( (@Autowired @Qualifier("person") | @Bean("person")) Person person, xxx){
...
}
Como você pode ver, a primavera tomou a decisão certa de tomar @ModelAttribute uma anotação abrangente; Ninguém quer ver uma anotação Smorgasbord.
Para o meu estilo, sempre uso @modelattribute para capturar objeto do formulário de mola JSP. Por exemplo, eu projete o formulário de JSP, esse formulário existe com comando nome
<form:form commandName="Book" action="" methon="post">
<form:input type="text" path="title"></form:input>
</form:form>
E eu pego o objeto no controlador com o código de seguimento
public String controllerPost(@ModelAttribute("Book") Book book)
e todo nome de campo do livro deve ser combinado com o caminho no subelemento de forma
Então, vou tentar explicar de maneira mais simples. Vamos ter:
public class Person {
private String name;
public String getName() {
return name;
}
public void setName(final String name) {
this.name = name;
}
}
Conforme descrito na documentação do MVC da primavera - o @Modelattribute Anotação pode ser usada em métodos ou em Argumentos do método. E é claro que podemos ter o uso ao mesmo tempo em um controlador.
1. Anotação do Mododo
@ModelAttribute(“cities”)
public List<String> checkOptions(){
return new Arrays.asList(new[]{“Sofia”,”Pleven","Ruse”});//and so on
}
O objetivo desse método é adicionar atributo no modelo. Então, no nosso caso cidades A chave terá a lista new Arras.asList(new[]{“Sofia”,”Pleven","Ruse”}) como valor no modelo (você pode pensar no modelo como mapa (chave: valor)). @Modelattribute Métodos em um controlador são invocados antes @RequestMapping métodos, dentro do mesmo controlador.
Aqui, queremos adicionar ao modelo informações comuns que serão usadas no formulário para exibir ao usuário. Por exemplo, ele pode ser usado para preencher um HTML Select:
2. Argumento de métodos
public String findPerson(@ModelAttriute(value="person") Person person) {
//..Some logic with person
return "person.jsp";
}
Um @modelattribute em um argumento de método indica que o argumento deve ser recuperado do modelo. Então, neste caso, esperamos que tenhamos no modelo pessoa objeto como chave e queremos obter seu valor e colocá -lo no argumento do método Pessoa pessoa. Se isso não existir ou (às vezes você ergue errado o (value = "Persson")), a primavera não a encontrará no modelo e criará um objeto Pessoa vazia usando seus padrões. Em seguida, levará os parâmetros de solicitação e tentará vinculá -los no objeto de pessoa usando seus nomes.
name="Dmitrij"&countries=Lesoto&sponsor.organization="SilkRoad"&authorizedFunds=&authorizedHours=&
Portanto, temos o nome e ele será vinculado ao pessoa.name usando setName (nome da string). Então em
//..Some logic with person
Temos acesso a esse nome preenchido com valor "Dimitrij".
É claro que a primavera pode vincular objetos mais complexos, como listas, mapas, lista de conjuntos de mapas e assim por diante, mas atrás da cena, faz com que a magia de ligação de dados.
Podemos ter ao mesmo tempo o Modelo Annotado Modelo e solicitar o Method Manipler com @modelattribute nos argumentos. Então temos que unir as regras.
É claro que temos toneladas de diferentes situações - os métodos @modelattribute também podem ser definidos em um @Controlleradvice e assim por diante ...
Eu sei que estou atrasado para a festa, mas eu vou citar, como eles dizem, "melhor tarde do que nunca".Então, vamos começar, Todo mundo tem suas próprias maneiras de explicar as coisas, deixe-me tentar resumir e simples para você em poucos passos com um exemplo;Suponha que você tenha um formulário simples, a forma.jsp
<form:form action="processForm" modelAttribute="student">
First Name : <form:input path="firstName" />
<br><br>
Last Name : <form:input path="lastName" />
<br><br>
<input type="submit" value="submit"/>
</form:form>
caminho="firstName" caminho="lastName" Estas são as áreas/propriedades no StudentClass quando o formulário é chamado de seus getters são chamados, mas uma vez apresentado os seus setters são chamados e seus valores são definidos no feijão que foi indicado no modelAttribute="estudante" na tag form.
Temos StudentController que inclui os seguintes métodos;
@RequestMapping("/showForm")
public String showForm(Model theModel){ //Model is used to pass data between
//controllers and views
theModel.addAttribute("student", new Student()); //attribute name, value
return "form";
}
@RequestMapping("/processForm")
public String processForm(@ModelAttribute("student") Student theStudent){
System.out.println("theStudent :"+ theStudent.getLastName());
return "form-details";
}
//@ModelAttribute("student") Student theStudent
//Spring automatically populates the object data with form data all behind the
//scenes
agora, finalmente, temos um formulário com detalhes.jsp
<b>Student Information</b>
${student.firstName}
${student.lastName}
Então, de volta para a pergunta " o Que é @ModelAttribute em Spring MVC?Um exemplo de definição de origem para você, http://www.baeldung.com/spring-mvc-and-the-modelattribute-annotation O @ModelAttribute é uma anotação que liga um parâmetro do método, ou método de retorno de valor para um atributo de modelo e, em seguida, expõe-lo para um modo de exibição da web.
O que realmente acontece é que ele fica todos os valores do formulário aqueles que foram enviados por ele e, em seguida, detém-los para associar ou atribuir-lhes o objeto.Ele funciona mesmo como o @RequestParameter onde só temos um parâmetro e atribuir o valor de algum campo.Única diferença é @ModelAttribute possui todos os dados do formulário em vez de um único parâmetro.Ele cria um bean para você que possui formulário enviado de dados a ser usado pelo desenvolvedor mais tarde.
Para recapitular a coisa toda.Passo 1 :O pedido é enviado, e o nosso método showForm e corre de um modelo, de uma temporárias de feijão é definido com o nome do aluno é encaminhado para o formulário.theModel.addAttribute("aluno", new Aluno());
Passo 2 :modelAttribute="estudante". no envio do formulário modelo altera o aluno e agora ele possui todos os parâmetros do formulário
Passo 3 :@ModelAttribute("aluno") Estudante estudante Devemos buscar os valores a serem retidos @ModelAttribute e atribuir todo o feijão/objeto para o Aluno.
Passo 4 :E, em seguida, nós o utilizamos como nós lance, assim como mostrar na página etc, como eu fiz
Eu espero que ele ajude você a entender o conceito.Obrigado
Tomar qualquer aplicação web se é o Gmail ou o Facebook ou Instagram ou qualquer outro aplicativo web, é tudo sobre a troca de dados ou informações entre o usuário final e o aplicativo ou a INTERFACE do usuário e o back-end da aplicação.Mesmo em Spring MVC mundo há duas maneiras de dados do exchange:
- a partir do Controlador para a INTERFACE do usuário, e
- de INTERFACE do usuário para o Controlador.
O que nos interessa aqui é a forma como os dados são comunicados a partir da INTERFACE do usuário para o Controlador.Isso também pode ser feito de 2 formas:
- Usando um Formulário HTML
- Usando Parâmetros De Consulta.
Usando um Formulário HTML:Considere o cenário abaixo,
Quando nos enviar o formulário de dados do navegador da web, podemos acessar os dados em nosso Controlador de classe de um objeto.Quando vamos enviar um formulário HTML, o Primavera Recipiente faz quatro coisas.Ele vai,
- primeiro, leia todos os dados que são enviados que vem o pedido usando o pedido.getParameter o método.
- depois de lê-los, ele irá convertê-los para o adequado tipo Java utilizando inteiro.parseInt, casal.parseDouble e todas as outras analisar os métodos que estão disponíveis com base no tipo de dados dos dados.
- uma vez analisado, ele irá criar um objeto da classe model que nós criamos.Por exemplo, neste cenário, é o usuário da informação que está sendo apresentado e vamos criar uma classe chamada Usuário, que o Container irá criar um objeto e ele irá definir todos os valores que entram automaticamente dentro do objeto.
- ele irá, em seguida, de entrega do objeto, definindo os valores para o Controlador.
Para obter essa coisa toda para funcionar, nós vamos ter que seguir certas etapas.
Primeiro precisamos definir um modelo de classe, como Usuário, em que o número de campos deve corresponder exatamente ao número de campos no formulário HTML.Além disso, os nomes que usamos no formulário HTML deve corresponder a nomes que temos em classe Java.Esses dois são muito importantes.Os nomes devem corresponder, o número de campos no formulário deve corresponder ao número de campos na classe que criamos.Uma vez que fazemos isso, o Recipiente automaticamente irá ler os dados que entra, cria um objeto do presente modelo, define os valores e as mãos para o Controlador.A leitura desses valores no interior do Controlador, usamos o @ModelAttribute anotação sobre os parâmetros do método.Quando criamos métodos do Controller, vamos usar o @ModelAttribute e adicionar um parâmetro de que terá automaticamente este objeto dado pelo Contêiner.
Aqui está um exemplo de código para registrar um nome de usuário:
@RequestMapping(value = "registerUser", method = RequestMethod.POST)
public String registerUser(@ModelAttribute("user") User user, ModelMap model) {
model.addAttribute("user", user);
return "regResult";
}
Espero que este diagramática explicação ajudou!
Isso é usado para fins de ligação de dados na primavera MVC. Deixe você ter um JSP com um elemento de formulário, por exemplo,
sobre
JSP
<form:form action="test-example" method="POST" commandName="testModelAttribute"> </form:form>
(Método da forma de mola, elemento de formulário simples também pode ser usado)
No lado do controlador
@RequestMapping(value = "/test-example", method = RequestMethod.POST)
public ModelAndView testExample(@ModelAttribute("testModelAttribute") TestModel testModel, Map<String, Object> map,...) {
}
Agora, quando você enviar o formulário, os valores do formulário estarão disponíveis para você.
Anotação que vincula um parâmetro de método ou valor de retorno de método a um atributo de modelo nomeado, exposto a uma visualização da Web.
public String add(@ModelAttribute("specified") Model model) {
...
}
@Modelattribute pode ser usado como argumentos / parâmetro do método ou antes da declaração do método. O objetivo principal desta anotação para vincular os parâmetros de solicitação ou formar campos a um objeto modelo
@ModelAttribute criará um atributo com o nome especificado por você (@ModelAttribute("Testing") Test test) as Testing No exemplo dado, o teste é o teste de feijão, sendo a referência ao feijão e os testes estarão disponíveis no modelo, para que você possa usá -lo ainda mais nas páginas JSP para recuperação de valores que você armazenou em você ModelAttribute.
@Modelattribute simplesmente vincula o valor dos campos JSP ao POJO CALSS para executar nossa lógica na classe do controlador. Se você estiver familiarizado com as suportes, é como preencher o objeto FormBean mediante envio.
A anotação ModelAttribute é usada como parte de um aplicativo da Web MVC da primavera e pode ser usada em dois cenários.
Primeiro de tudo, ele pode ser usado para injetar dados em um modelo de carga pré-JSP. Isso é especialmente útil para garantir que um JSP seja necessário para exibir todos os dados. Uma injeção é obtida conectando um método ao modelo.
Segundo, ele pode ser usado para ler dados de um modelo existente e atribuí -los aos parâmetros do método do treinador.
Refrão https://dzone.com/articles/using-spring-mvc%E2%80%99s
