Spring Controller und RestController Anleitung
Einführung in den Spring Controller
Die Spring Controller Annotation ist eine Spezialisierung der @Component Annotation. Sie wird typischerweise in Kombination mit annotierten Handlermethoden verwendet, die auf der RequestMapping-Annotation basieren.
Spring Controller
Die Spring Controller Annotation kann nur auf Klassen angewendet werden. Sie wird verwendet, um eine Klasse als Handler für Webanfragen zu kennzeichnen. Sie wird meistens in Spring MVC-Anwendungen verwendet.
Spring RestController
Spring @RestController ist eine praktische Annotation, die selbst mit @Controller und @ResponseBody annotiert ist. Diese Annotation wird verwendet, um eine Klasse als Request Handler für REST-basierte Webdienste zu kennzeichnen.
Beispiel für Spring Controller
Lassen Sie uns eine einfache Spring-Anwendung erstellen, in der wir sowohl einen Standard-MVC-Controller als auch einen REST-Controller implementieren. Erstellen Sie ein „Dynamic Web Project“ in Eclipse und konvertieren Sie es dann in ein Maven-Projekt. Dadurch erhalten wir eine maven-basierte Webanwendungsstruktur, auf der wir unsere Anwendung aufbauen können. Das folgende Bild zeigt die endgültige Projektstruktur unserer Spring MVC Controller-Anwendung.
Wir benötigen folgende Abhängigkeiten für unsere Anwendung.
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.0.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.0.7.RELEASE</version>
</dependency>
<!-- Jackson für REST -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.6</version>
</dependency>
Schauen wir uns den Bereitstellungsdeskriptor (web.xml) an, wo wir den DispatcherServlet Servlet als Frontcontroller konfigurieren werden.
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns="https://xmlns.jcp.org/xml/ns/javaee"
xsi:schemaLocation="https://xmlns.jcp.org/xml/ns/javaee https://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
<display-name>Spring-Controller</display-name>
<!-- Fügen Sie Spring MVC DispatcherServlet als Frontcontroller hinzu -->
<servlet>
<servlet-name>spring</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring-servlet.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>spring</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
Schließlich haben wir die folgende Spring-Kontextdatei. Hier konfigurieren wir unsere Anwendung als annotierungsbasiert und geben das Stammpaket für das Scannen von Spring-Komponenten an. Wir konfigurieren auch den InternalResourceViewResolver-Bean und geben Details zu den Ansichtsseiten an.
<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="https://www.springframework.org/schema/mvc"
xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns:beans="https://www.springframework.org/schema/beans"
xmlns:context="https://www.springframework.org/schema/context"
xsi:schemaLocation="https://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
https://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!-- Aktiviert das Spring MVC @Controller Programmiermodell -->
<annotation-driven />
<context:component-scan base-package="com.journaldev.spring" />
<!-- Löst Ansichten, die von @Controllers zur Darstellung ausgewählt wurden, zu JSP-Ressourcen
im Verzeichnis /WEB-INF/views auf -->
<beans:bean
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<beans:property name="prefix" value="/WEB-INF/views/" />
<beans:property name="suffix" value=".jsp" />
</beans:bean>
</beans:beans>
Konfiguration der Controller-Klasse
Unsere Konfigurations-XML-Dateien sind bereit, lasst uns nun zur Controller-Klasse übergehen.
package com.journaldev.spring.controller;
import java.text.DateFormat;
import java.util.Date;
import java.util.Locale;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
@Controller
public class HomeController {
@GetMapping("/hello")
public String home(Locale locale, Model model) {
Date date = new Date();
DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, locale);
String formattedDate = dateFormat.format(date);
model.addAttribute("serverTime", formattedDate);
return "home";
}
}
Konfiguration der Spring-Kontextdatei
Schließlich haben wir die folgende Spring-Kontextdatei. Hier konfigurieren wir unsere Anwendung als annotierungsbasiert und geben das Stammpaket für das Scannen von Spring-Komponenten an. Wir konfigurieren auch den InternalResourceViewResolver-Bean und geben Details zu den Ansichtsseiten an.
<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="https://www.springframework.org/schema/mvc"
xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns:beans="https://www.springframework.org/schema/beans"
xmlns:context="https://www.springframework.org/schema/context"
xsi:schemaLocation="https://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
https://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!-- Aktiviert das Spring MVC @Controller Programmiermodell -->
<annotation-driven />
<context:component-scan base-package="com.journaldev.spring" />
<!-- Löst Ansichten, die von @Controllers zur Darstellung ausgewählt wurden, zu JSP-Ressourcen
im Verzeichnis /WEB-INF/views auf -->
<beans:bean
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<beans:property name="prefix" value="/WEB-INF/views/" />
<beans:property name="suffix" value=".jsp" />
</beans:bean>
</beans:beans>
Implementierung des Spring MVC Controllers und REST Controllers
Unsere Konfigurations-XML-Dateien sind bereit, lasst uns nun zur Controller-Klasse übergehen.
package com.journaldev.spring.controller;
import java.text.DateFormat;
import java.util.Date;
import java.util.Locale;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
@Controller
public class HomeController {
@GetMapping("/hello")
public String home(Locale locale, Model model) {
Date date = new Date();
DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, locale);
String formattedDate = dateFormat.format(date);
model.addAttribute("serverTime", formattedDate);
return "home";
}
}
Wir haben eine einzelne Request-Handler-Methode definiert, die GET-Anfragen mit der URI „/hello“ akzeptiert und die Seite „home.jsp“ als Antwort zurückgibt. Beachten Sie, dass wir ein Attribut zum Modell hinzufügen, das auf der Seite home.jsp verwendet wird. Hier ist unser einfacher Code für die Seite home.jsp.
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<html>
<head>
<title>Home</title>
</head>
<body>
<h1>Hallo Welt!</h1>
<p>Die Serverzeit ist ${serverTime}.</p>
</body>
</html>
Test des Spring MVC Controllers
Unsere herkömmliche, auf Servlets basierende Spring MVC-Anwendung mit einem einfachen Controller ist fertig. Exportieren Sie sie einfach als WAR-Datei und deployen Sie sie auf Tomcat oder einem anderen Servlet-Container. Gehen Sie dann zur URL https://localhost:8080/Spring-Controller/hello und Sie sollten folgenden Bildschirm als Ausgabe sehen.
Beispiel für Spring RestController
Jetzt erweitern wir unsere Anwendung, um auch REST-APIs anzubieten. Erstellen Sie eine Modellklasse, die als JSON-Antwort gesendet wird.
package com.journaldev.spring.model;
public class Person {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Hier ist unsere einfache REST-Controller-Klasse.
package com.journaldev.spring.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.journaldev.spring.model.Person;
@RestController
public class PersonRESTController {
@RequestMapping("/rest")
public String healthCheck() {
return "OK";
}
@RequestMapping("/rest/person/get")
public Person getPerson(@RequestParam(name = "name", required = false, defaultValue = "Unbekannt") String name) {
Person person = new Person();
person.setName(name);
return person;
}
}
Setzen Sie das Deployment der Anwendung erneut ein, um unsere REST-APIs zu testen.
Test des Spring REST Controllers
Gehen Sie zur URL https://localhost:8080/Spring-Controller/rest und Sie sollten folgende Ausgabe erhalten.
Gehen Sie zur URL https://localhost:8080/Spring-Controller/rest/person/get und Sie erhalten folgende JSON-Antwort.
Geben Sie jetzt den Namen als Parameterwert in der URL an, gehen Sie zu https://localhost:8080/Spring-Controller/rest/person/get?name=Pankaj und Sie erhalten folgende JSON-Antwort.
Zusammenfassung
Der Spring Controller ist das Rückgrat von Spring MVC-Anwendungen. Hier beginnt unsere Anleitung. Darüber hinaus erleichtert uns der RestController das Erstellen von REST-basierten Webdiensten.
