jersey => Ondersteuning voor Jersey MVC

Invoering

MVC Frameworks zoals Spring MVC gebruiken om webapplicaties te maken die dynamische webpagina's dienen. Jersey, hoewel bekend als een REST Framework, biedt ook ondersteuning voor het maken van dynamische webpagina's met behulp van de MVC-module.

Jersey MVC Hallo wereld

Maak om te beginnen een nieuwe Maven-webapp (dit valt buiten het bestek van dit voorbeeld). Voeg in uw pom.xml de volgende twee afhankelijkheden toe

<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>

Voeg in de pom ook de jetty-maven-plugin die we tijdens de ontwikkeling van de applicatie zullen gebruiken

<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>

Nu kunnen we onze controllers maken. In elk MVC-raamwerk zijn de concepten meestal hetzelfde. U hebt een sjabloon en u gebruikt een controller om een model te vullen dat zal worden gebruikt om de sjabloon weer te geven. De term "renderen" wordt hier gebruikt om aan te geven dat de uiteindelijke HTML-pagina moet worden gemaakt door de sjabloon en het model te combineren Neem bijvoorbeeld deze sjabloon

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

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

Dit is een JSP-bestand. JSP is slechts een van de door Engine ondersteunde template-engines. Hier gebruiken we twee modelvariabelen, hello en world . Verwacht wordt dat deze twee variabelen in het model zitten dat wordt gebruikt om deze sjabloon weer te geven. Laten we dus de controller toevoegen

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);
    }
}

Je kunt hier zien dat we het model vullen met de eigenschappen hello en world . Ook retourneert de controller-methode de naam van de weergavesjabloon die moet worden gebruikt, in dit geval index . Hiermee weet het framework de "indexsjabloon" te pakken en het meegeleverde model te gebruiken om het weer te geven.

Nu moeten we het alleen nog configureren. Voeg een ResourceConfig subklasse toe met het volgende

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);
    }
}

Er zijn hier drie dingen aan de hand:

We gebruiken packages om Jersey te laten com.example.controller pakket com.example.controller moet scannen voor klassen die zijn geannoteerd met @Path , zodat het het kan registreren. In dit geval registreert het onze HomeController .
We bepalen het basispad voor het framework om sjablonen op te lossen. In dit geval vertellen we Jersey om in de WEB-INF/jsp naar sjablonen te zoeken. Je kunt het index.jsp voorbeeld hierboven zien in de in deze regisseur. Ook in de controller terug te keren we gewoon de template naam index . Dit wordt gebruikt om de sjabloon te vinden, door het basispad van de configuratie te prefixen en een impliciete .jsp achtervolgen
We moeten de functie registreren die JSP-rendering afhandelt. Zoals eerder vermeld, is JSP niet de enige rendering-engine die wordt ondersteund door Jersey. Er worden er nog een paar ondersteund.

Het laatste wat we moeten doen is Jersey configureren in de web.xml

<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 configureren we Jersey gewoon om onze AppConfig klasse te gebruiken. Een heel belangrijk ding om hier op te wijzen, is het gebruik van het <filter> plaats van wat u normaal zou zien, een <servlet> . Dit is vereist bij het gebruik van JSP als de sjabloon-engine.

Nu kunnen we het uitvoeren. Voer vanaf de opdrachtregel mvn jetty:run . Hiermee wordt de Maven Jetty-plug-in uitgevoerd die we eerder hebben geconfigureerd. Wanneer u "Started Jetty Server" ziet, is de server gereed. Ga naar de browser-URL http://localhost:8080/ . Voila, "Hallo wereld". Genieten.

Zie de Jersey-documentatie voor MVC-sjablonen voor meer informatie

Modified text is an extract of the original Stack Overflow Documentation

Licentie onder CC BY-SA 3.0

Niet aangesloten bij Stack Overflow

jersey
Ondersteuning voor Jersey MVC

Zoeken…

Invoering

Jersey MVC Hallo wereld