Panduan Pantas untuk Pengawal Musim Semi

1. Pengenalan

Dalam artikel ini kita akan memfokuskan pada konsep teras dalam Spring MVC - Controllers.

2. Gambaran keseluruhan

Mari mulakan dengan melangkah ke belakang dan melihat konsep Front Controller dalam seni bina Spring Model View Controller yang khas .

Pada tahap yang sangat tinggi, berikut adalah tanggungjawab utama yang sedang kita lihat:

  • Memintas permintaan masuk
  • Menukar muatan permintaan ke struktur dalaman data
  • Menghantar data ke Model untuk diproses lebih lanjut
  • Mendapat data yang diproses dari Model dan memajukan data tersebut ke View untuk rendering

Berikut adalah gambarajah ringkas untuk aliran tahap tinggi di Spring MVC :

Seperti yang anda lihat, DispatcherServlet memainkan peranan sebagai Pengawal Depan dalam seni bina.

Gambar rajah tersebut berlaku untuk pengawal MVC biasa dan juga pengawal RESTful - dengan beberapa perbezaan kecil (diterangkan di bawah).

Dalam pendekatan tradisional, aplikasi MVC tidak berorientasikan perkhidmatan sehingga ada V iew Resolver yang memberikan pandangan akhir berdasarkan data yang diterima dari Pengawal .

Aplikasi RESTful direka untuk berorientasikan perkhidmatan dan mengembalikan data mentah (biasanya JSON / XML). Oleh kerana aplikasi ini tidak melakukan rendering pandangan, tidak ada View Resolvers - Pengawal umumnya diharapkan dapat mengirim data secara langsung melalui respons HTTP.

Mari kita mulakan dengan pengawal gaya MVC0.

3. Pergantungan Maven

Untuk dapat bekerjasama dengan Spring MVC , mari kita menangani pergantungan Maven terlebih dahulu:

 org.springframework spring-webmvc 5.0.6.RELEASE 

Untuk mendapatkan versi terkini perpustakaan, lihat spring-webmvc di Maven Central.

4. Konfigurasi Web Projek

Sekarang, sebelum melihat pengawal itu sendiri, pertama-tama kita perlu membuat projek web mudah dan melakukan konfigurasi Servlet yang cepat .

Mari kita lihat terlebih dahulu bagaimana DispatcherServlet dapat disiapkan tanpa menggunakan web.xml - tetapi sebaliknya menggunakan inisialisasi:

public class StudentControllerConfig implements WebApplicationInitializer { @Override public void onStartup(ServletContext sc) throws ServletException { AnnotationConfigWebApplicationContext root = new AnnotationConfigWebApplicationContext(); root.register(WebConfig.class); root.refresh(); root.setServletContext(sc); sc.addListener(new ContextLoaderListener(root)); DispatcherServlet dv = new DispatcherServlet(new GenericWebApplicationContext()); ServletRegistration.Dynamic appServlet = sc.addServlet("test-mvc", dv); appServlet.setLoadOnStartup(1); appServlet.addMapping("/test/*"); } }

Untuk mengatur semuanya tanpa XML, pastikan servlet-api 3.1.0 di classpath anda.

Begini rupa web.xml :

 test-mvc  org.springframework.web.servlet.DispatcherServlet  1  contextConfigLocation /WEB-INF/test-mvc.xml   

Kami menetapkan harta konteksConfigLocation di sini - menunjuk ke fail XML yang digunakan untuk memuat konteks Spring. Sekiranya harta itu tidak ada, Spring akan mencari fail bernama {servlet_name} -servlet.xml .

Dalam kes kami servlet_name adalah test-mvc dan demikian, dalam contoh ini DispatcherServlet akan mencari fail yang disebut test-mvc-servlet.xml .

Akhirnya, mari kita siapkan DispatcherServlet dan memetakannya ke URL tertentu - untuk menyelesaikan sistem berasaskan Front Controller kami di sini:

 test-mvc /test/* 

Oleh itu, dalam kes ini, DispatcherServlet akan memintas semua permintaan dalam corak / ujian / * .

5. Spring MVC Web Config

Mari kita lihat bagaimana Dispatcher Servlet dapat disiapkan menggunakan Spring Config :

@Configuration @EnableWebMvc @ComponentScan(basePackages= { "com.baeldung.controller.controller", "com.baeldung.controller.config" }) public class WebConfig implements WebMvcConfigurer { @Override public void configureDefaultServletHandling( DefaultServletHandlerConfigurer configurer) { configurer.enable(); } @Bean public ViewResolver viewResolver() { InternalResourceViewResolver bean = new InternalResourceViewResolver(); bean.setPrefix("/WEB-INF/"); bean.setSuffix(".jsp"); return bean; } }

Sekarang mari kita melihat penyediaan Servlet Dispatcher menggunakan XML . Petikan fail DispatcherServlet XML - fail XML yang digunakan oleh DispatcherServlet untuk memuatkan pengawal tersuai dan entiti Spring yang lain ditunjukkan di bawah:

    /WEB-INF/   .jsp  

Berdasarkan konfigurasi sederhana ini, kerangka kerja tentu akan menginisialisasi mana-mana kacang pengawal yang akan dijumpainya di classpath.

Perhatikan bahawa kami juga mendefinisikan View Resolver, yang bertanggungjawab untuk rendering pandangan - kami akan menggunakan Spring's InternalResourceViewResolver di sini. Ini menjangka yang nama pandangan yang perlu diselesaikan, yang cara mencari halaman yang sama dengan menggunakan awalan dan akhiran (kedua-dua yang ditakrifkan dalam XML konfigurasi).

Jadi, sebagai contoh jika Pengawal mengembalikan pandangan bernama " selamat datang" , yang pandangan resolver akan cuba untuk menyelesaikan halaman yang dipanggil "welcome.jsp" dalam WEB-INF folder.

6. Pengawal MVC

Mari kita akhirnya melaksanakan pengawal gaya MVC.

Perhatikan bagaimana kita mengembalikan objek ModelAndView - yang mengandungi peta model dan objek pandangan ; kedua-duanya akan digunakan oleh V iew Resolver untuk rendering data:

@Controller @RequestMapping(value = "/test") public class TestController { @GetMapping public ModelAndView getTestData() { ModelAndView mv = new ModelAndView(); mv.setViewName("welcome"); mv.getModel().put("data", "Welcome home man"); return mv; } }

Jadi, apa sebenarnya yang kami sediakan di sini.

Pertama, kami membuat pengawal yang dipanggil TestController dan memetakannya ke jalan "/ test" . Dalam kelas kami telah mencipta satu kaedah yang mengembalikan ModelAndView objek dan dipetakan kepada GET permintaan dengan itu apa-apa panggilan URL yang berakhir dengan " ujian " akan dihalakan oleh DispatcherServlet kepada getTestData kaedah dalam TestController .

And of course we're returning the ModelAndView object with some model data for good measure.

The view object has a name set to “welcome“. As discussed above, the View Resolver will search for a page in the WEB-INF folder called “welcome.jsp“.

Below you can see the result of an example GET operation:

Note that the URL ends with “test”. The pattern of the URL is “/test/test“.

The first “/test” comes from the Servlet, and the second one comes from the mapping of the controller.

7. More Spring Dependencies for REST

Let's now start looking at a RESTful controller. Of course, a good place to start is the extra Maven dependencies we need for it:

  org.springframework spring-webmvc 5.0.6.RELEASE   org.springframework spring-web 5.0.6.RELEASE   com.fasterxml.jackson.core jackson-databind 2.9.5   

Please refer to jackson-core, spring-webmvc and spring-web links for the newest versions of those dependencies.

Jackson is of course not mandatory here, but it's certainly a good way to enable JSON support. If you're interested to dive deeper into that support, have a look at the message converters article here.

8. The REST Controller

The setup for a Spring RESTful application is the same as the one for the MVC application with the only difference being that there is no View Resolvers and no model map.

The API will generally simply return raw data back to the client – XML and JSON representations usually – and so the DispatcherServlet bypasses the view resolvers and returns the data right in the HTTP response body.

Let's have a look at a simple RESTful controller implementation:

@Controller public class RestController { @GetMapping(value = "/student/{studentId}") public @ResponseBody Student getTestData(@PathVariable Integer studentId) { Student student = new Student(); student.setName("Peter"); student.setId(studentId); return student; } }

Note the @ResponseBody annotation on the method – which instructs Spring to bypass the view resolver and essentially write out the output directly to the body of the HTTP response.

A quick snapshot of the output is displayed below:

The above output is a result of sending the GET request to the API with the student id of 1.

One quick note here is – the @RequestMapping annotation is one of those central annotations that you'll really have to explore in order to use to its full potential.

9. Spring Boot and the @RestController Annotation

The @RestController annotation from Spring Boot is basically a quick shortcut that saves us from always having to define @ResponseBody.

Here's the previous example controller using this new annotation:

@RestController public class RestAnnotatedController { @GetMapping(value = "/annotated/student/{studentId}") public Student getData(@PathVariable Integer studentId) { Student student = new Student(); student.setName("Peter"); student.setId(studentId); return student; } }

10. Conclusion

Dalam panduan ini, kami meneroka asas penggunaan pengawal pada musim bunga, baik dari sudut aplikasi MVC biasa dan juga RESTful API.

Sudah tentu semua kod dalam artikel boleh didapati di GitHub.