jersey => Jersey MVC-Unterstützung

Einführung

MVC-Frameworks wie Spring MVC verwenden zum Erstellen von Webanwendungen, die dynamische Webseiten bereitstellen. Jersey ist zwar als REST-Framework bekannt, unterstützt aber auch die Erstellung dynamischer Webseiten mit seinem MVC-Modul.

Jersey MVC Hallo Welt

Um zu beginnen, erstellen Sie eine neue Maven-Webapp (diese Vorgehensweise liegt außerhalb des Anwendungsbereichs dieses Beispiels). Fügen Sie in Ihrer pom.xml die folgenden zwei Abhängigkeiten hinzu

<dependency>
    <groupId>org.glassfish.jersey.containers</groupId>
    <artifactId>jersey-container-servlet</artifactId>
    <version>2.25.1</version>
</dependency>
<dependency>
    <groupId>org.glassfish.jersey.ext</groupId>
    <artifactId>jersey-mvc-jsp</artifactId>
    <version>2.25.1</version>
</dependency>

jetty-maven-plugin auch im pom das jetty-maven-plugin , das wir während der Entwicklung verwenden

<build>
    <finalName>jersey-mvc-hello-world</finalName>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>2.5.1</version>
            <inherited>true</inherited>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
            </configuration>
        </plugin>

        <plugin>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-maven-plugin</artifactId>
            <version>9.3.8.v20160314</version>
        </plugin>
    </plugins>
</build>

Jetzt können wir unsere Controller erstellen. In jedem MVC-Framework sind die Konzepte normalerweise gleich. Sie haben eine Vorlage und Sie verwenden einen Controller, um ein Modell aufzufüllen, das zum Rendern der Vorlage verwendet wird. Der Begriff "Rendern" wird hier verwendet, um die endgültige HTML-Seite zu erstellen, indem die Vorlage und das Modell kombiniert werden. Nehmen Sie zum Beispiel diese Vorlage

src / main / webapp / WEB-INF / jsp / index.jsp

<html>
    <head>
        <title>JSP Page</title>
    </head>
    <body>
        <h1>${it.hello} ${it.world}</h1>
    </body>
</html>

Dies ist eine JSP-Datei. JSP ist nur eine der von Jersey unterstützten Template-Engines. Hier verwenden wir zwei Modellvariablen, hello und world . Es wird erwartet, dass sich diese beiden Variablen in dem Modell befinden, das zum Rendern dieser Vorlage verwendet wird. Fügen wir also den Controller hinzu

package com.example.controller;

import org.glassfish.jersey.server.mvc.Viewable;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import java.util.HashMap;
import java.util.Map;

@Path("/")
public class HomeController {

    @GET
    @Produces(MediaType.TEXT_HTML)
    public Viewable index() {
        Map<String, String> model = new HashMap<>();
        model.put("hello", "Hello");
        model.put("world", "World");
        return new Viewable("/index", model);
    }
}

Sie sehen hier, dass wir das Modell mit den Eigenschaften hello und world hello . Die Controller-Methode gibt auch den Namen der Ansichtsvorlage zurück, die verwendet werden soll, in diesem Fall index . Damit kann das Framework die "Index" -Vorlage verwenden und das bereitgestellte Modell zum Rendern verwenden.

Jetzt müssen wir es nur noch konfigurieren. Fügen Sie eine ResourceConfig Unterklasse mit den folgenden hinzu

package com.example;

import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.server.mvc.jsp.JspMvcFeature;

public class AppConfig extends ResourceConfig {

    public AppConfig() {
        packages("com.example.controller");
        property(JspMvcFeature.TEMPLATE_BASE_PATH, "/WEB-INF/jsp");
        register(JspMvcFeature.class);
    }
}

Hier sind drei Dinge los:

Wir verwenden packages , um Jersey @Path , dass es das com.example.controller Paket nach mit @Path annotierten Klassen @Path , damit es es registrieren kann. In diesem Fall registriert es unseren HomeController .
Wir legen den Basispfad für das Framework fest, um Vorlagen aufzulösen. In diesem Fall fordern wir Jersey auf, im WEB-INF/jsp nach Vorlagen zu suchen. Sie können das index.jsp Beispiel oben in diesem Director sehen. Auch in der Steuerung kehren wir nur den Namen der Vorlage index . Dies wird verwendet, um die Vorlage zu finden, indem dem Konfigurationsbasispfad ein .jsp wird und ein implizites .jsp
Wir müssen die Funktion registrieren, die das JSP-Rendering übernimmt. Wie bereits erwähnt, ist JSP nicht die einzige von Jersey unterstützte Rendering-Engine. Es gibt ein paar mehr, die sofort unterstützt werden.

Das letzte, was wir tun müssen, ist Jersey in der web.xml zu konfigurieren

<filter>
    <filter-name>Jersey</filter-name>
    <filter-class>org.glassfish.jersey.servlet.ServletContainer</filter-class>
    <init-param>
        <param-name>javax.ws.rs.Application</param-name>
        <param-value>com.example.AppConfig</param-value>
    </init-param>
</filter>

<filter-mapping>
    <url-pattern>/*</url-pattern>
    <filter-name>Jersey</filter-name>
</filter-mapping>

Hier konfigurieren wir Jersey, um unsere AppConfig Klasse zu verwenden. Eine sehr wichtige Sache, die hier hervorgehoben werden muss, ist die Verwendung des <filter> anstelle dessen, was Sie normalerweise sehen würden, ein <servlet> . Dies ist erforderlich, wenn JSP als Template-Engine verwendet wird.

Jetzt können wir es ausführen. Führen Sie von der Befehlszeile aus mvn jetty:run . Dadurch wird das zuvor konfigurierte Maven Jetty-Plugin ausgeführt. Wenn "Started Jetty Server" angezeigt wird, ist der Server bereit. Gehen Sie zur Browser-URL http://localhost:8080/ . Voila, "Hallo Welt". Genießen.

Weitere Informationen finden Sie in der Jersey-Dokumentation für MVC-Vorlagen

Modified text is an extract of the original Stack Overflow Documentation

Lizenziert unter CC BY-SA 3.0

Nicht angeschlossen an Stack Overflow

jersey
Jersey MVC-Unterstützung

Suche…

Einführung

Jersey MVC Hallo Welt