Что такое @ModelAttribute в Spring MVC?

@ModelAttribute относится к свойству объекта Model (M в MVC;), поэтому предположим, что у нас есть форма с объектом поддержки формы, который называется «Person». Затем вы можете настроить Spring MVC для передачи этого объекта в метод контроллера с помощью @ModelAttribute аннотация:

public String processForm(@ModelAttribute("person") Person person){
    person.getStuff();
}

С другой стороны, аннотация используется для определения объектов, которые должны быть частью модели. Поэтому, если вы хотите, чтобы в модели была ссылка на объект Person, вы можете использовать следующий метод:

@ModelAttribute("person")
public Person getPerson(){
    return new Person();
}

Этот аннотированный метод позволит получить доступ к объекту Person в вашем представлении, поскольку он автоматически добавляется в модели Spring.

См. "Использование @ModelAttribute ".

Я знаю, что это старая ветка, но я подумал, что брошу шляпу в кольцо и посмотрю, смогу ли я еще немного замутить воду :)

Я обнаружил, что мои первые попытки понять @ModelAttribute были результатом решения Spring объединить несколько аннотаций в одну. Это стало яснее, когда я разделил его на несколько более мелких аннотаций:

Что касается аннотаций параметров, подумайте о @ModelAttribute как о эквиваленте @Autowired + @Qualifier, т.е. он пытается получить bean-компонент с заданным именем из управляемой модели Spring. Если именованный компонент не найден, вместо выдачи ошибки или возврата null он неявно берет на себя роль @Bean, т.е. создает новый экземпляр, используя конструктор по умолчанию, и добавляет компонент в модель.

Что касается аннотаций методов, считайте @ModelAttribute эквивалентом @Bean + @Before, то есть он помещает компонент, созданный кодом пользователя, в модель и всегда вызывается перед методом обработки запроса.

Образно говоря, я вижу @ModelAttribute как следующее (пожалуйста, не принимайте это буквально !!):

@Bean("person")
@Before
public Person createPerson(){
  return new Person();
}

@RequestMapping(...)
public xxx handlePersonRequest( (@Autowired @Qualifier("person") | @Bean("person")) Person person, xxx){
  ...
}

Как видите, Spring принял правильное решение, сделав @ModelAttribute всеобъемлющую аннотацию; никто не хочет видеть шведский стол аннотаций.

В своем стиле я всегда использую @ModelAttribute, чтобы поймать объект из пружинной формы jsp. например, я создаю форму на странице jsp, эта форма существует с commandName

<form:form commandName="Book" action="" methon="post">
      <form:input type="text" path="title"></form:input>
</form:form>

и я ловлю объект на контроллере с помощью следующего кода

public String controllerPost(@ModelAttribute("Book") Book book)

и каждое имя поля книги должно совпадать с путем в подэлементе формы

Поэтому я постараюсь объяснить это попроще. Давайте:

public class Person {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(final String name) {
        this.name = name;
    }
}

Как описано в документации Spring MVC, аннотация @ModelAttribute может использоваться в методах или в аргументах метода. И, конечно, мы можем использовать оба одновременно в одном контроллере.

1. Аннотация метода

@ModelAttribute(“cities”)
 public List<String> checkOptions(){
 return new Arrays.asList(new[]{“Sofia”,”Pleven","Ruse”});//and so on
}

Назначение такого метода - добавить атрибут в модель. Таким образом, в нашем случае ключ города будет иметь список new Arras.asList(new[]{“Sofia”,”Pleven","Ruse”}) как значение в модели (вы можете думать о модели как о карте (ключ: значение)). Методы @ModelAttribute в контроллере вызываются перед методами @RequestMapping в том же контроллере.

Здесь мы хотим добавить в модель общую информацию, которая будет использоваться в форме для отображения пользователю. Например, его можно использовать для заполнения выбора HTML:

2-й аргумент метода

public String findPerson(@ModelAttriute(value="person") Person person) {
    //..Some logic with person
    return "person.jsp";
}

Атрибут @ModelAttribute в аргументе метода указывает, что аргумент должен быть получен из модели. Итак, в этом случае мы ожидаем, что у нас есть объект модели person в качестве ключа, и мы хотим получить его значение и поместить его в аргумент метода Person. Если такой не существует или (иногда вы неправильно пишете (value = "persson")), то Spring не найдет его в модели и создаст пустой объект Person, используя его значения по умолчанию. Затем примет параметры запроса и попытается привязать данные к объекту Person, используя их имена.

name="Dmitrij"&countries=Lesoto&sponsor.organization="SilkRoad"&authorizedFunds=&authorizedHours=&

Итак, у нас есть имя, и оно будет привязано к Person.name с помощью setName (String name). Так что в

//..Some logic with person

у нас есть доступ к этому заполненному имени со значением «Димитрий».

Конечно, Spring может связывать более сложные объекты, такие как списки, карты, список наборов карт и так далее, но за кулисами он создает волшебство привязки данных.

3. Мы можем иметь одновременно аннотированный метод модели и обработчик метода запроса с @ModelAttribute в аргументах. Затем мы должны объединить правила.

4. Конечно, у нас есть масса разных ситуаций - методы @ModelAttribute также могут быть определены в @ControllerAdvice и так далее ...

Я знаю, что опаздываю на вечеринку, но я процитирую, как они говорят, «лучше опоздать, чем никогда». Итак, приступим. У каждого есть свои способы объяснить вещи, позвольте мне попытаться подвести итог и упростить для вас в несколько шагов с помощью примера; Предположим, у вас есть простая форма form.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>

path = "firstName" path = "lastName" Это поля / свойства в StudentClass, когда форма вызывается, вызываются их геттеры, но после отправки вызываются их сеттеры, и их значения устанавливаются в bean-компоненте, который был указан в modelAttribute = "студент" в теге формы.

У нас есть StudentController, который включает следующие методы;

@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 

теперь, наконец, у нас есть form-details.jsp

<b>Student Information</b>
${student.firstName}
${student.lastName}

Итак, вернемся к вопросу, что такое @ModelAttribute в Spring MVC? Пример определения из источника для вас, http://www.baeldung.com/spring-mvc-and-the-modelattribute-annotation @ModelAttribute - это аннотация, которая связывает параметр метода или возвращаемое значение метода с именованной моделью. атрибут, а затем предоставляет его веб-представлению.

На самом деле происходит то, что он получает все значения вашей формы, которые были отправлены им, и затем хранит их, чтобы вы могли связать или назначить их объекту. Он работает так же, как @RequestParameter, где мы только получаем параметр и присваиваем значение некоторому полю. Единственная разница в том, что @ModelAttribute содержит все данные формы, а не один параметр. Он создает для вас bean-компонент, который содержит данные, отправленные из формы, которые разработчик может использовать позже.

Подводя итог всему этому. Шаг 1: отправляется запрос, запускается наш метод showForm, и в форму передается модель, временный bean-компонент с именем student. theModel.addAttribute ("студент", новый студент ());

Шаг 2: modelAttribute = "student" в модели отправки формы изменяет учащегося, и теперь он содержит все параметры формы.

Шаг 3: @ModelAttribute ("student") Student theStudent Мы извлекаем значения, удерживаемые @ModelAttribute и назначить весь компонент / объект Студенту.

Шаг 4: А затем мы используем его в качестве ставки, так же, как показываем на странице и т. Д., Как это сделал я.

Надеюсь, это поможет вам понять концепцию. Спасибо

Возьмите любое веб-приложение, будь то Gmail, Facebook, Instagram или любое другое веб-приложение, все дело в обмене данными или информацией между конечным пользователем и приложением или пользовательским интерфейсом и серверным приложением. Даже в мире Spring MVC есть два способа обмена данными:

1. от контроллера к пользовательскому интерфейсу и
2. из пользовательского интерфейса в контроллер.

Что нас интересует, так это то, как данные передаются от пользовательского интерфейса к контроллеру. Это также можно сделать двумя способами:

1. Использование HTML-формы
2. Использование параметров запроса.

Использование HTML-формы: рассмотрим приведенный ниже сценарий.

Когда мы отправляем данные формы из веб-браузера, мы можем получить доступ к этим данным в нашем классе Controller как к объекту. Когда мы отправляем HTML-форму, контейнер Spring выполняет четыре действия. Так и будет,

1. сначала прочтите все данные, которые поступают в запрос, с помощью метода request.getParameter.
2. как только он их прочитает, он преобразует их в соответствующий тип Java, используя integer.parseInt, double.parseDouble и все другие методы синтаксического анализа, доступные в зависимости от типа данных. данных.
3. после анализа он создаст объект класса модели, который мы создали. Например, в этом сценарии отправляется информация о пользователе, и мы создаем класс с именем User, объект которого будет создан Контейнером, и он установит все значения, которые поступают автоматически в этот объект.
4. Затем он передаст этот объект, установив значения в Контроллер.

Чтобы все это заработало, нам нужно будет выполнить определенные шаги.

Сначала нам нужно определить класс модели, например User, в котором количество полей должно точно соответствовать количеству полей в HTML-форме. Кроме того, имена, которые мы используем в HTML-форме, должны совпадать с именами, которые мы имеем в классе Java. Эти двое очень важны. Имена должны совпадать, количество полей в форме должно совпадать с количеством полей в создаваемом нами классе. Как только мы это сделаем, Контейнер автоматически прочитает входящие данные, создаст объект этой модели, установит значения и передаст их Контроллеру. Чтобы прочитать эти значения внутри контроллера, мы используем аннотацию @ModelAttribute для параметров метода. Когда мы создаем методы в Контроллере, мы собираемся использовать @ModelAttribute и добавить к нему параметр, который автоматически получит этот объект из Контейнера.

Вот пример кода для регистрации пользователя:

@RequestMapping(value = "registerUser", method = RequestMethod.POST)
public String registerUser(@ModelAttribute("user") User user, ModelMap model) {
    model.addAttribute("user", user);
    return "regResult";
}

Надеюсь, это схематическое объяснение помогло!

@ModelAttribute может использоваться в качестве аргументов / параметра метода или перед объявлением метода. Основная цель этой аннотации - привязать параметры запроса или поля формы к объекту модели.

Ref. http://www.javabeat.net/modelattribute-spring-mvc/

Это используется для привязки данных в Spring MVC. Пусть у вас есть jsp с элементом формы, например

on JSP

<form:form action="test-example" method="POST" commandName="testModelAttribute"> </form:form>

(Метод Spring Form, также можно использовать простой элемент формы)

На стороне контроллера

@RequestMapping(value = "/test-example", method = RequestMethod.POST)
public ModelAndView testExample(@ModelAttribute("testModelAttribute") TestModel testModel, Map<String, Object> map,...) {

}

Теперь, когда вы отправите форму, вам будут доступны значения полей формы.

Аннотация, которая связывает параметр метода или возвращаемое значение метода с именованным атрибутом модели, доступным для веб-представления.

public String add(@ModelAttribute("specified") Model model) {
    ...
}

@ModelAttribute создаст атрибут с именем, указанным вами (@ModelAttribute("Testing") Test test) as Testing в данном примере, Test - это bean-тест, являющийся ссылкой на bean-компонент, а Testing будет доступен в модели, чтобы вы могли в дальнейшем использовать его на страницах jsp для получения значений, которые ты хранил в тебе ModelAttribute.

@ModelAttribute просто связывает значение из полей jsp с Pojo calss для выполнения нашей логики в классе контроллера. Если вы знакомы со стойками, то это похоже на заполнение объекта-формы при отправке.

Аннотация ModelAttribute используется как часть веб-приложения Spring MVC и может использоваться в двух сценариях.

Прежде всего, его можно использовать для вставки данных в модель загрузки до JSP. Это особенно полезно для обеспечения того, чтобы JSP-страница отображала все данные. Инъекция получается подключением к модели одного метода.

Во-вторых, его можно использовать для чтения данных из существующей модели и присвоения их параметрам метода тренера.

ссылка https://dzone.com/articles/using-spring-mvc%E2%80%99s

На уровне метода

1.Когда аннотация используется на уровне метода, она указывает, что цель этого метода - добавить один или несколько атрибутов модели.

@ModelAttribute
public void addAttributes(Model model) {
model.addAttribute("india", "india");
}

В аргументе метода 1. При использовании в качестве аргумента метода он указывает, что аргумент должен быть получен из модели. Если они отсутствуют и должны быть сначала созданы, а затем добавлены в модель, а после того, как они присутствуют в модели, поля аргументов должны быть заполнены из всех параметров запроса с совпадающими именами. Таким образом, он связывает данные формы с bean-компонентом.

 @RequestMapping(value = "/addEmployee", method = RequestMethod.POST)
  public String submit(@ModelAttribute("employee") Employee employee) {
  return "employeeView";
  }