Apa itu @ModelAttribute di Spring MVC?

Apa tujuan dan penggunaan @ModelAttributedi Spring MVC?

@ModelAttributemerujuk ke properti objek Model (M dalam MVC;) jadi katakanlah kita memiliki formulir dengan objek dukungan bentuk yang disebut "Person". Kemudian Anda dapat meminta Spring MVC menyuplai objek ini ke metode Controller dengan menggunakan @ModelAttributeanotasi. :

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

Di sisi lain anotasi digunakan untuk mendefinisikan objek yang harus menjadi bagian dari Model. Jadi jika Anda ingin memiliki objek Orang yang dirujuk dalam Model, Anda dapat menggunakan metode berikut:

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

Metode beranotasi ini akan memungkinkan akses ke objek Orang di Tampilan Anda, karena itu akan secara otomatis ditambahkan ke Model oleh Spring.

Lihat "Menggunakan @ModelAttribute" .

Saya tahu ini adalah utas lama, tetapi saya pikir saya melemparkan topi saya di atas ring dan melihat apakah saya dapat mengeruhkan sedikit air :)

Saya menemukan perjuangan awal saya untuk memahami @ModelAttributeadalah hasil dari keputusan Spring untuk menggabungkan beberapa anotasi menjadi satu. Itu menjadi lebih jelas setelah saya membaginya menjadi beberapa anotasi yang lebih kecil:

Untuk anotasi parameter, anggap @ModelAttributesetara dengan @Autowired + @Qualifierartinya mencoba mengambil kacang dengan nama yang diberikan dari model terkelola Spring. Jika kacang bernama tidak ditemukan, alih-alih melempar kesalahan atau kembali null, itu secara implisit mengambil peran @Beanyaitu Buat contoh baru menggunakan konstruktor default dan tambahkan kacang ke model.

Untuk penjelasan metode, anggap @ModelAttributesetara dengan @Bean + @Before, yaitu menempatkan kacang yang dibuat oleh kode pengguna dalam model dan selalu dipanggil sebelum metode penanganan permintaan.

Secara kiasan, saya melihat @ModelAttributesebagai berikut (tolong jangan menerimanya secara harfiah !!):

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

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

Seperti yang Anda lihat, Spring membuat keputusan yang tepat untuk membuat @ModelAttributeanotasi yang mencakup semuanya; tidak ada yang ingin melihat smorgasbord anotasi.

Untuk gaya saya, saya selalu menggunakan @ModelAttribute untuk menangkap objek dari spring form jsp. misalnya, saya mendesain formulir di halaman jsp, formulir itu ada dengan commandName

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

dan saya menangkap objek pada controller dengan mengikuti kode

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

dan setiap bidang nama buku harus cocok dengan jalur di sub-elemen formulir

Jadi saya akan mencoba menjelaskannya dengan cara yang lebih sederhana. Mari kita miliki:

public class Person {
    private String name;

    public String getName() {
        return name;
    }

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

Seperti dijelaskan dalam dokumentasi Spring MVC - anotasi @ModelAttribute dapat digunakan pada metode atau argumen metode . Dan tentu saja kita bisa menggunakan keduanya sekaligus dalam satu kontroler.

1.Metode penjelasan

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

Tujuan dari metode tersebut adalah untuk menambahkan atribut dalam model. Jadi dalam kasus kami, kunci kota akan memiliki daftar new Arras.asList(new[]{“Sofia”,”Pleven","Ruse”})sebagai nilai dalam Model (Anda dapat menganggap Model sebagai peta (kunci: nilai)). Metode @ModelAttribute dalam controller dipanggil sebelum metode @RequestMapping , dalam controller yang sama.

Di sini kami ingin menambahkan Model informasi umum yang akan digunakan dalam bentuk untuk ditampilkan kepada pengguna. Misalnya itu dapat digunakan untuk mengisi HTML pilih:

2.Metode argumen

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

@ModelAttribute pada argumen metode menunjukkan argumen harus diambil dari model. Jadi dalam hal ini kami berharap bahwa kami memiliki objek Model orang sebagai kunci dan kami ingin mendapatkan nilainya dan memasukkannya ke metode argumen Person person . Jika seperti itu tidak ada atau (kadang-kadang Anda salah mengeja (nilai = "persson")) maka Spring tidak akan menemukannya di Model dan akan membuat objek Person kosong menggunakan default-nya. Kemudian akan mengambil parameter permintaan dan mencoba data mengikatnya di objek Orang menggunakan nama mereka.

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

Jadi kita memiliki nama dan itu akan diikat ke Person.name menggunakan setName (nama String). Jadi masuk

//..Some logic with person

kami memiliki akses ke nama yang diisi ini dengan nilai "Dimitrij".

Tentu saja Spring dapat mengikat objek yang lebih kompleks seperti Daftar, Peta, Daftar Set Peta dan sebagainya, tetapi di belakang layar itu membuat data mengikat sihir.

3. Kita dapat pada saat yang sama memodelkan metode beranotasi dan meminta penangan metode dengan @ModelAttribute dalam argumen. Maka kita harus menyatukan aturan.

4. Tentu saja kami memiliki banyak situasi berbeda - metode @ModelAttribute juga dapat didefinisikan dalam @ControllerAdvice dan seterusnya ...

Saya tahu saya terlambat ke pesta, tapi saya akan mengutip seperti yang mereka katakan, "lebih baik terlambat daripada tidak pernah". Jadi mari kita mulai, Semua orang memiliki cara mereka sendiri untuk menjelaskan sesuatu, izinkan saya mencoba untuk meringkasnya dan menyederhanakannya untuk Anda dalam beberapa langkah dengan sebuah contoh; Misalkan Anda memiliki formulir sederhana, 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" Ini adalah bidang / properti di StudentClass ketika formulir disebut getter mereka dipanggil tetapi setelah diserahkan setternya dipanggil dan nilainya diatur dalam kacang yang ditunjukkan dalam modelAttribute = "siswa" di tag formulir.

Kami memiliki StudentController yang mencakup metode berikut;

@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 

sekarang akhirnya kami memiliki form-details.jsp

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

Jadi kembali ke pertanyaan Apa itu @ModelAttribute in Spring MVC? Definisi sampel dari sumber untuk Anda, http://www.baeldung.com/spring-mvc-and-the-modelattribute-annotation The @ModelAttribute adalah anotasi yang mengikat parameter metode atau metode nilai kembali ke atribut model bernama dan kemudian memaparkannya ke tampilan web.

Apa yang sebenarnya terjadi adalah ia mendapatkan semua nilai dari formulir Anda yang dikirimkan olehnya dan kemudian menahannya untuk Anda ikat atau tetapkan ke objek. Ia bekerja sama seperti @RequestParameter di mana kami hanya mendapatkan parameter dan menetapkan nilai ke beberapa bidang. Satu-satunya perbedaan adalah @ModelAttribute menyimpan semua data formulir daripada parameter tunggal. Itu menciptakan kacang untuk Anda yang memegang formulir mengirimkan data untuk digunakan oleh pengembang nanti.

Untuk merangkum semuanya. Langkah 1: Permintaan dikirim dan metode kami showForm berjalan dan model, kacang sementara diatur dengan nama siswa diteruskan ke formulir. theModel.addAttribute ("student", Student baru ());

Langkah 2: modelAttribute = "student" pada model pengiriman formulir mengubah siswa dan sekarang memegang semua parameter formulir

Langkah 3: @ModelAttribute ("student") Student theStudent Kami mengambil nilai yang dipegang oleh @ModelAttribute dan menugaskan seluruh bean / objek ke Student.

Langkah 4: Dan kemudian kita menggunakannya saat kita menawar, seperti menunjukkannya pada halaman dll seperti yang saya lakukan

Saya harap ini membantu Anda memahami konsepnya. Terima kasih

Ambil aplikasi web apa pun baik itu Gmail atau Facebook atau Instagram atau aplikasi web lainnya, semuanya tentang bertukar data atau informasi antara pengguna akhir dan aplikasi atau UI dan aplikasi ujung belakang. Bahkan di dunia Spring MVC ada dua cara untuk bertukar data:

1. dari Pengontrol ke UI, dan
2. dari UI ke Controller.

Yang kami minati di sini adalah bagaimana data dikomunikasikan dari UI ke Controller. Ini juga dapat dilakukan dengan 2 cara:

1. Menggunakan Formulir HTML
2. Menggunakan Parameter Kueri.

Menggunakan Formulir HTML: Pertimbangkan skenario di bawah ini,

Saat kami mengirimkan data formulir dari browser web, kami bisa mengakses data itu di kelas Pengontrol kami sebagai objek. Saat kami mengirimkan formulir HTML, Spring Container melakukan empat hal. Itu akan,

1. pertama-tama baca semua data yang dikirimkan yang datang dalam permintaan menggunakan metode request.getParameter .
2. setelah membacanya, ia akan mengubahnya menjadi tipe Java yang tepat dengan menggunakan Integer.parseInt , double.parseDouble dan semua metode parse lain yang tersedia berdasarkan jenis data data.
3. setelah diuraikan, itu akan membuat objek dari kelas model yang kita buat. Misalnya, dalam skenario ini, itu adalah informasi pengguna yang dikirimkan dan kami membuat kelas yang disebut Pengguna, yang akan dibuat oleh Kontainer objek dan akan mengatur semua nilai yang masuk secara otomatis ke objek itu.
4. kemudian akan menyerahkan objek itu dengan menetapkan nilai ke Controller.

Untuk menyelesaikan semua ini, kita harus mengikuti langkah-langkah tertentu.

Pertama-tama kita perlu mendefinisikan kelas model, seperti Pengguna, di mana jumlah bidang harus sama persis dengan jumlah bidang dalam bentuk HTML. Juga, nama yang kita gunakan dalam formulir HTML harus cocok dengan nama yang kita miliki di kelas Java. Keduanya sangat penting. Nama harus cocok, jumlah bidang dalam formulir harus cocok dengan jumlah bidang di kelas yang kita buat. Setelah kami melakukannya, Container akan secara otomatis membaca data yang masuk, membuat objek model ini, menetapkan nilai-nilai dan menyerahkannya ke Controller. Untuk membaca nilai-nilai di dalam Controller, kami menggunakan @ModelAttributepenjelasan tentang parameter metode. Ketika kita membuat metode di Controller, kita akan menggunakan @ModelAttribute dan menambahkan parameter padanya yang secara otomatis akan memiliki objek ini diberikan oleh Container.

Berikut adalah contoh kode untuk mendaftarkan pengguna:

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

Semoga penjelasan diagram ini membantu!

Ini digunakan untuk tujuan pengikatan data di Spring MVC. Biarkan Anda memiliki jsp yang memiliki elemen form misalnya

di JSP

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

(Metode Spring Form, elemen bentuk sederhana juga dapat digunakan)

Di Sisi Pengendali

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

}

Sekarang ketika Anda akan mengirimkan formulir, nilai bidang formulir akan tersedia untuk Anda.

Anotasi yang mengikat parameter metode atau nilai pengembalian metode ke atribut model bernama, terkena tampilan web.

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

@ModelAttribute dapat digunakan sebagai argumen / parameter metode atau sebelum deklarasi metode. Tujuan utama anotasi ini untuk mengikat parameter permintaan atau formulir bidang ke objek model

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

@ModelAttributeakan membuat atribut dengan nama yang ditentukan oleh Anda (@ModelAttribute("Testing") Test test) as Testing dalam contoh yang diberikan, Tes menjadi tes kacang menjadi referensi ke kacang dan Pengujian akan tersedia dalam model sehingga Anda dapat lebih lanjut menggunakannya di halaman jsp untuk pengambilan nilai yang Anda simpan di dalam kamu ModelAttribute.

@ModelAttribute hanya mengikat nilai dari bidang jsp ke calss Pojo untuk melakukan logika kita di kelas controller. Jika Anda terbiasa dengan struts, maka ini seperti mengisi objek formbean saat pengiriman.

Anotasi ModelAttribute digunakan sebagai bagian dari aplikasi Web Spring MVC dan dapat digunakan dalam dua skenario.

Pertama-tama, ini dapat digunakan untuk menyuntikkan data ke dalam model beban pra-JSP. Ini sangat berguna dalam memastikan bahwa JSP diperlukan untuk menampilkan semua data itu sendiri. Suntikan diperoleh dengan menghubungkan satu metode ke model.

Kedua, dapat digunakan untuk membaca data dari model yang ada dan menetapkannya ke parameter metode pelatih.

refrence https://dzone.com/articles/using-spring-mvc%E2%80%99s

Di Level Metode

1. Ketika penjelasan digunakan pada level metode, ini menunjukkan tujuan metode tersebut adalah untuk menambahkan satu atau lebih atribut model

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

Pada Argumen Metode 1. Ketika digunakan sebagai argumen metode, ini menunjukkan argumen harus diambil dari model. Ketika tidak ada dan harus pertama kali instantiated dan kemudian ditambahkan ke model dan sekali hadir dalam model, bidang argumen harus diisi dari semua parameter permintaan yang memiliki nama yang cocok Jadi, itu mengikat data formulir dengan kacang.

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