1. Einführung
In diesem Artikel konzentrieren wir uns auf ein Kernkonzept in Spring MVC - Controller.
2. Überblick
Beginnen wir mit einem Schritt zurück und werfen Sie einen Blick auf das Konzept des __Front-Controllers in der typischen Spring-Model-Controller-Architektur.
Auf einer sehr hohen Ebene sind hier die Hauptaufgaben, mit denen wir uns befassen:
-
Fängt eingehende Anfragen ab
-
Konvertiert die Nutzdaten der Anforderung in die interne Struktur der
Daten ** Sendet die Daten zur weiteren Verarbeitung an Model
-
Ruft verarbeitete Daten aus dem Model ab und leitet diese Daten an den
View zum Rendern
Hier ist ein schnelles Diagramm für den übergeordneten Fluss in Spring MVC :
Wie Sie sehen, spielt das DispatcherServlet die Rolle des Front-Controllers in der Architektur.
Das Diagramm gilt sowohl für typische MVC-Controller als auch für RESTful-Controller - mit einigen kleinen Unterschieden (siehe unten).
In der traditionellen Herangehensweise sind MVC -Anwendungen nicht dienstorientiert, daher gibt es einen V iew Resolver, der endgültige Ansichten basierend auf Daten darstellt, die von einem Controller__ empfangen wurden.
RESTful -Anwendungen sind serviceorientiert und geben Rohdaten zurück (typischerweise JSON/XML). Da diese Anwendungen kein View-Rendering durchführen, gibt es keine View Resolvers - der Controller sendet normalerweise Daten direkt über die HTTP-Antwort.
Beginnen wir mit den MVC0-Steuerungen.
3. Abhängigkeiten von Maven
Um mit Spring MVC arbeiten zu können, lassen Sie uns zunächst die Maven-Abhängigkeiten behandeln:
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.0.6.RELEASE</version>
<dependency>Um die neueste Version der Bibliothek zu erhalten, besuchen Sie https://mvnrepository.com/artifact/org.springframework/spring-webmvc [spring-webmvc in Maven Central.
4. Projekt Web Config
Bevor wir uns die Controller selbst ansehen, müssen wir zunächst ein einfaches Webprojekt einrichten und eine schnelle Servlet -Konfiguration vornehmen.
Zuerst sehen wir, wie das DispatcherServlet eingerichtet werden kann, ohne web.xml zu verwenden - stattdessen einen Initialisierer:
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/** ");
}
}Um Dinge ohne XML einzurichten, muss servlet-api 3.1.0 in Ihrem Klassenpfad enthalten sein.
So sieht die web.xml aus:
<servlet>
<servlet-name>test-mvc</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/test-mvc.xml</param-value>
</init-param>
</servlet>Wir setzen hier die contextConfigLocation -Eigenschaft, die auf die XML -Datei verweist, die zum Laden des Spring-Kontexts verwendet wird. Wenn die Eigenschaft nicht vorhanden ist, sucht Spring nach einer Datei mit dem Namen \ {servlet name} -servlet.xml__.
In unserem Fall ist servlet name test-mvc und in diesem Beispiel würde DispatcherServlet nach einer Datei mit dem Namen test-mvc-servlet.xml__ suchen.
Als letztes setzen wir das DispatcherServlet auf und ordnen es einem bestimmten URL zu - um unser Front Controller -basiertes System hier zu beenden:
<servlet-mapping>
<servlet-name>test-mvc</servlet-name>
<url-pattern>/test/** </url-pattern>
</servlet-mapping>In diesem Fall würde das DispatcherServlet alle Anforderungen innerhalb des Musters /test/** abfangen.
5. Spring MVC Web Config
Schauen wir uns nun an, wie das Dispatcher Servlet mit Spring Config eingerichtet werden kann:
@Configuration
@EnableWebMvc
@ComponentScan(basePackages= {
"org.baeldung.controller.controller",
"org.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;
}
}Schauen wir uns nun das Dispatcher-Servlet mit XML an. Eine Momentaufnahme der DispatcherServlet-XML -Datei - der XML -Datei, die das DispatcherServlet zum Laden von benutzerdefinierten controllers und anderen Spring entities verwendet, wird unten angezeigt:
<context:component-scan base-package="com.baledung.controller"/>
<mvc:annotation-driven/>
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix">
<value>/WEB-INF/</value>
</property>
<property name="suffix">
<value>.jsp</value>
</property>
</bean>Basierend auf dieser einfachen Konfiguration initialisiert das Framework natürlich alle Controller-Beans, die im Klassenpfad gefunden werden.
Beachten Sie, dass wir auch den View Resolver definieren, der für das View-Rendering verantwortlich ist. Wir verwenden hier InternalResourceViewResolver von Spring.
Dies erwartet, dass der Name eines view aufgelöst wird, was bedeutet, dass eine entsprechende Seite mithilfe von Präfix und Suffix (beide in der XML -Konfiguration definiert) gefunden werden.
Wenn der Controller beispielsweise eine view mit dem Namen " welcome" ** zurückgibt, versucht der view __resolver eine Seite namens "welcome.jsp" im Ordner WEB-INF aufzulösen.
6. Der MVC-Controller
Lassen Sie uns den MVC-Controller nicht endgültig implementieren.
Beachten Sie, wie wir ein ModelAndView -Objekt zurückgeben, das eine model map und ein view-Objekt enthält. Beide werden vom V _iew Resolver _ für das Rendern von Daten verwendet:
@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;
}
}Was genau haben wir hier eingerichtet?
Zuerst haben wir einen Controller mit dem Namen TestController erstellt und dem Pfad "/test" zugeordnet. In der Klasse haben wir eine Methode erstellt, die ein ModelAndView -Objekt zurückgibt und einer GET -Anforderung zugeordnet wird. Daher würde jeder mit " test " endende URL-Aufruf von der DispatcherServlet -Methode an die getTestData -Methode in der TestController -Route weitergeleitet.
Und natürlich geben wir das ModelAndView -Objekt zusammen mit einigen Modelldaten für ein gutes Maß zurück.
Das Ansichtsobjekt hat einen Namen, der auf „ welcome “ gesetzt ist. Wie oben beschrieben, sucht der View Resolver nach einer Seite im WEB-INF -Ordner mit dem Namen „ welcome.jsp “.
Unten sehen Sie das Ergebnis einer Beispieloperation GET :
Beachten Sie, dass die URL mit "test" endet. Das Muster der URL ist „/test/test “.
Das erste “/test” kommt vom Servlet, das zweite vom Mapping des Controllers.
** 7. Weitere Frühlingsabhängigkeiten für REST
**
Beginnen wir nun mit einem RESTful-Controller. Natürlich ist ein guter Anfang die zusätzlichen Maven-Abhängigkeiten, die wir dafür benötigen:
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.0.6.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.0.6.RELEASE</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.5</version>
</dependency>
</dependencies>Weitere Informationen finden Sie unter jackson-core , https://mvnrepository.com/artifact/org.springframework/spring-webmvc webmvc]und spring-web Links für die neuesten Versionen dieser Abhängigkeiten.
Jackson ist hier natürlich nicht obligatorisch, aber es ist sicherlich eine gute Möglichkeit, die JSON-Unterstützung zu aktivieren. Wenn Sie sich näher mit dieser Unterstützung beschäftigen möchten, schauen Sie sich den Link an:/spring-httpmessageconverter-rest[Nachrichtenkonverter hier].
** 8. Der REST-Controller
**
Das Setup für eine Spring RESTful -Anwendung ist das gleiche wie das für die MVC -Anwendung. Der einzige Unterschied besteht darin, dass es keine V _iew Resolvers und keine model map._ gibt.
Die API gibt im Allgemeinen einfach Rohdaten zurück an die Client-Repräsentationen ( XML und JSON ). Daher umgeht DispatcherServlet den view-Auflöser und gibt die Daten im HTTP-Antworttext zurück.
Schauen wir uns eine einfache RESTful-Controller-Implementierung an:
@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;
}
}Beachten Sie die Annotation @ ResponseBody zu der Methode. Diese Anweisung weist Spring an, den view resolver zu umgehen, und schreibt die Ausgabe im Wesentlichen direkt in den Hauptteil der HTTP-Antwort .
Eine kurze Momentaufnahme der Ausgabe wird unten angezeigt:
Die obige Ausgabe ergibt sich aus dem Senden der GET -Anforderung an die API mit der Schüler- id von 1 .
Eine kurze Anmerkung hier ist: die Annotation @ RequestMapping ist eine dieser zentralen Anmerkungen, die Sie wirklich erkunden müssen, um ihr volles Potenzial auszuschöpfen.
9. Spring Boot und die @ RestController Annotation
Die @ RestController -Annotation von Spring Boot ist im Grunde eine schnelle Verknüpfung, die es uns erspart, immer @ ResponseBody definieren zu müssen.
Hier ist der vorherige Beispielcontroller, der diese neue Anmerkung verwendet:
@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. Fazit
In diesem Handbuch werden die Grundlagen der Verwendung von Controllern in Spring erläutert, und zwar sowohl aus Sicht einer typischen MVC-Anwendung als auch einer RESTful-API.
Natürlich ist der gesamte Code in diesem Artikel verfügbar: https://github.com/eugenp/tutorials/tree/master/spring-spring-allildover auf Giuthub.