Что такое @ModelAttribute в Spring MVC?
Какова цель и использование @ModelAttribute весной MVC?
15 ответов
@ModelAttribute ссылается на свойство объекта Model (M в MVC;), так что давайте представим, что у нас есть форма с объектом поддержки формы, который называется "Person". Затем вы можете заставить Spring MVC передать этот объект в метод Controller, используя @ModelAttribute аннотация:
public String processForm(@ModelAttribute("person") Person person){
person.getStuff();
}
Посмотрите здесь пример (Spring 2.5), также смотрите "Использование @ModelAttribute для аргумента метода" (Spring 3.1).
С другой стороны, аннотация используется для определения объектов, которые должны быть частью модели. Поэтому, если вы хотите, чтобы объект Person упоминался в модели, вы можете использовать следующий метод:
@ModelAttribute("person")
public Person getPerson(){
return new Person();
}
Этот аннотированный метод позволит получить доступ к объекту Person в вашем представлении, поскольку он автоматически добавляется в модели Spring.
Смотрите раздел "Использование @ModelAttribute для метода" (Spring 3.1).
Надеюсь, это помогло.
Я знаю, что это старая нить, но я подумал, что я брошу свою шляпу в кольцо и посмотрю, смогу ли я немного запачкать воду:)
Я нашел свою первоначальную борьбу, чтобы понять @ModelAttribute был результатом решения Spring объединить несколько аннотаций в одну. Это стало яснее, когда я разделил его на несколько небольших аннотаций:
Для аннотаций параметров, подумайте о @ModelAttribute как эквивалент @Autowired + @Qualifier то есть он пытается получить компонент с заданным именем из управляемой модели 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 всеобъемлющая аннотация; никто не хочет видеть аннотацию шведского стола.
Поэтому я постараюсь объяснить это более простым способом. Давайте:
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 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 может связывать более сложные объекты, такие как списки, карты, списки наборов карт и т. Д., Но за сценой это делает магию привязки данных.
В то же время мы можем иметь аннотированный метод и обработчик метода запроса с @ModelAttribute в аргументах. Тогда мы должны объединить правила.
Конечно, у нас есть множество различных ситуаций - методы @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 запускается, и модель, в которой установлен временный бин с именем ученика, перенаправляется в форму. theModel.addAttribute ("студент", новый студент ());
Шаг 2: modelAttribute="student" при отправке формы модель меняет студента, и теперь она содержит все параметры формы
Шаг 3: @ModelAttribute ("student") Student theStudent Мы извлекаем значения, удерживаемые @ModelAttribute, и присваиваем весь bean/ объект объекту Student.
Шаг 4: А затем мы используем его в качестве ставки, так же, как показываем его на странице и т.д., как я сделал
Я надеюсь, что это поможет вам понять концепцию. Спасибо
Для моего стиля я всегда использую @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)
и каждое имя поля книги должно совпадать с путем в подэлементе формы
Возьмите любое веб-приложение, будь то Gmail, Facebook, Instagram или любое другое веб-приложение, это все об обмене данными или информацией между конечным пользователем и приложением или пользовательским интерфейсом и внутренним приложением. Даже в мире Spring MVC есть два способа обмена данными:
- от контроллера к пользовательскому интерфейсу, и
- от пользовательского интерфейса до контроллера.
Здесь нас интересует, как данные передаются из интерфейса в контроллер. Это также можно сделать двумя способами:
- Использование формы HTML
- Использование параметров запроса.
Использование формы HTML: рассмотрим следующий сценарий:
Когда мы отправляем данные формы из веб-браузера, мы можем получить доступ к этим данным в нашем классе Controller как объект. Когда мы отправляем HTML-форму, Spring Container выполняет четыре вещи. Будет,
- сначала прочитайте все данные, представленные в запросе, используя метод request.getParameter.
- как только он прочитает их, он преобразует их в соответствующий тип Java, используя integer.parseInt, double.parseDouble и все другие методы синтаксического анализа, доступные на основе типа данных данных.
- после анализа он создаст объект класса модели, который мы создали. Например, в этом сценарии отправляется информация о пользователе, и мы создаем класс с именем User, для которого контейнер будет создавать объект, и он будет устанавливать все значения, которые автоматически поступают в этот объект.
- Затем он передаст этот объект, установив значения для контроллера.
Чтобы заставить все это работать, мы должны следовать определенным шагам.
Сначала нам нужно определить класс модели, такой как 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";
}
Надеюсь, что это схематическое объяснение помогло!
Это используется для привязки данных в Spring MVC, Пусть у вас есть jsp с элементом формы, например
на
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 создаст атрибут с указанным вами именем (@ModelAttribute("Testing") Test test) as Testing в данном примере Test - это bean-тест, являющийся ссылкой на bean-компонент, и Testing будет доступен в модели, чтобы вы могли в дальнейшем использовать его на страницах jsp для получения значений, которые вы сохранили в себе. ModelAttribute,
@ModelAttribute просто привязывает значение из полей jsp к Calfo Pojo для выполнения нашей логики в классе контроллера. Если вы знакомы с распорками, то это похоже на заполнение формбэя при подаче.
Аннотация @ModelAttribute используется как часть веб-приложения Spring MVC и может использоваться в двух сценариях.
Во-первых, его можно использовать для внедрения объектов данных в модель до загрузки JSP. Это делает его особенно полезным для обеспечения того, чтобы JSP имел все данные, необходимые для отображения. Инжекция достигается путем привязки возвращаемого значения метода к модели. Во-вторых, его можно использовать для чтения данных из существующей модели, присваивая их параметрам метода-обработчика. Чтобы продемонстрировать @ModelAttributes, я использую самый простой сценарий: добавление учетной записи пользователя в гипотетическую систему, а затем, после создания учетной записи пользователя, отображение сведений о новом пользователе на экране приветствия.
Чтобы начать движение, мне понадобится простой бин User с некоторыми знакомыми полями: имя, фамилия, никнейм и адрес электронной почты - обычные подозреваемые.
На уровне метода
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";
}
Во-первых, модели используются в MVC Spring (MVC = Model, View, Controller). При этом модели используются вместе с «представлениями».
Что это за взгляды? Представления могут представлять собой «html-страницы, созданные нашей внутренней структурой (в нашем случае Spring) с некоторыми переменными данными в некоторых частях html-страницы».
Итак, у нас есть модель, которая представляет собой сущность, содержащую данные, которые «внедряются» в представление.
Есть несколько библиотек «представления», с которыми можно работать со Spring: среди них JSP, Thymeleaf, Mustache и другие.
Например, предположим, что мы используем Thymeleaf (они все похожи. Более того, Spring даже не знает, кроме JSP, с какими библиотеками представлений он работает. Все модели обслуживаются через сервлет Spring. Это означает, что код Spring будет одинаковым для всех этих библиотек представлений, единственное, что вам нужно изменить, это синтаксис таких html-страниц, которые находятся в resources/static/templates)
resources/static/templates //All our view web pages are here
Контроллер заботится о маршрутах. Допустим, например, что наш сайт размещен на локальном хосте: 8080. Нам нужен маршрут (URL), показывающий нам студентов. Допустим, это доступно по адресу localhost:8080/students. Контроллер, который сделает это, — StudentController:
@Controller //Not @RestController
public class StudentController {
@GetMapping(/students)
public String getStudentView() {
return "student";
}
}
Этот код говорит, что если мы собираемся
локальный хост:8080/студенты
затем вызывается метод getStudentView(). Но обратите внимание, что он должен возвращать строку. Однако при работе с библиотекой представлений, а контроллер аннотирован с помощью @Controller (а не @RestController), то, что делает spring, ищет страницу просмотра html с именем строки, которую возвращает метод, в нашем случае это будет искать вид на
/resources/static/templates/student.html
Этого достаточно для статических страниц без данных. Однако, если нам нужна динамическая страница с некоторыми данными, Spring предлагает еще одно большое преимущество: метод getStudentView(), описанный выше, также будет передавать модель в наше представление «student.html». Наша модель будет содержать данные, к которым мы можем получить доступ в файле «student.html», используя специальный синтаксис из нашей библиотеки представлений. Например, с листьями тимьяна:
<div th:text="${attribute1}"> </div>
Это позволит получить доступ к атрибуту «attribute1» нашей модели. Мы можем передавать различные данные через нашу модель. Это делается путем присвоения ему различных атрибутов. Существуют разные способы назначения атрибутов с помощью @ModelAttribute:
@Controller //Not @RestController
public class StudentController {
@ModelAttribute(name = "attribute1")
public int assignAttribute1() {
return 123454321
} // Think it as "model.attribute1 = 123454321"
@GetMapping(/students)
public String getStudentView() {
return "student";
}
}
Приведенный выше код присвоит модели (созданной под капотом) атрибут с именем «attribute1» (представьте, что это ключ) со значением 12354321. Что-то вроде «model.attribute1 = 123454321».
Наконец, модель передается в представление, когда мы переходим по URL-адресу.
локальный хост:8080/студенты
Примечание: все методы, аннотированные с помощью @ModelAttribute, вызываются до того, как будет возвращено представление. Модель после создания всех атрибутов передается нашему представлению. проще говоря, после вызова метода getStudentView() вызываются все методы с @ModelAttribute.
При этом html-код, написанный выше, будет просматриваться в браузере как:
<div> 123454321 </div> // th:text is a command of
//THymeleaf, and says to substitute the text
// between the tags with the attribute "attribute1"
// of our model passed to this view.
Это основное использование @ModelAttribute.
Есть еще один важный вариант использования:
Модель может понадобиться в обратном направлении: т. е. от представления к контроллеру. В случае, описанном выше, модель передается от контроллера к представлению. Однако предположим, что пользователь с нашей html-страницы отправляет обратно некоторые данные. Мы можем поймать его без атрибутов модели, @ModelAttribute. Это уже описано другими
Аннотация ModelAttribute используется как часть веб-приложения Spring MVC и может использоваться в двух сценариях.
Прежде всего, его можно использовать для ввода данных в модель нагрузки до JSP. Это особенно полезно для обеспечения того, что JSP требуется для отображения всех данных. Инъекция получается путем подключения одного метода к модели.
Во-вторых, его можно использовать для считывания данных из существующей модели и назначения их параметрам метода тренера.
ссылка https://dzone.com/articles/using-spring-mvc%E2%80%99s