jersey => Jersey MVC Support

Introduktion

MVC-ramverk som Spring MVC använder för att skapa webbapplikationer som serverar dynamiska webbsidor. Trots att Jersey är känt för att vara en REST Framework, har han också stöd för att skapa dynamiska webbsidor med sin MVC-modul.

Jersey MVC Hello World

För att komma igång, skapa en ny Maven-webbapp (hur du gör det ligger utanför exemplet). Lägg till följande två beroenden i din pom.xml

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

I pom, lägg till jetty-maven-plugin som vi ska använda för att köra applikationen under utvecklingen

<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 kan vi skapa våra kontroller. I alla MVC-ramar är koncepten vanligtvis desamma. Du har en mall och du använder en kontroller för att fylla i en modell som kommer att användas för att återge mallen. Termen "render" här används för att skapa den slutliga HTML-sidan genom att kombinera mallen och modellen Ta till exempel den här mallen

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

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

Detta är en JSP-fil. JSP är bara en av de mallmotorer som stöds av Jersey. Här använder vi två modellvariabler, hello och world . Det förväntas att dessa två variabler kommer att finnas i modellen som används för att göra denna mall. Så låt oss lägga till regulatorn

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

Du kan se här vi fyller modellen med egenskaperna hello och world . Även styrmetoden returnerar namnet på den visningsmall som ska användas, i detta fall index . Med detta vet ramverket att ta tag i "index" -mallen och använda den medföljande modellen för att göra den.

Nu behöver vi bara konfigurera det. Lägg till en ResourceConfig underklass med följande

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

Det här finns tre saker här:

Vi använder packages att berätta för Jersey att skanna com.example.controller paketet för klasser som är kommenterade med @Path för att det kan registrera det. I detta fall registrerar den vår HomeController .
Vi ställer in basvägen för ramverket för att lösa mallar. I det här fallet ber vi Jersey att titta i WEB-INF/jsp för mallar. Du kan se index.jsp exemplet ovan i i denna regissör. Även i regulatorn återvänder vi bara mallnamnet index . Detta kommer att användas för att hitta mallen, genom att förkonfigurera konfigurationsbasvägen och efterföra en implicit .jsp
Vi måste registrera funktionen som hanterar JSP-rendering. Som nämnts tidigare är JSP inte den enda återgivningsmotorn som stöds av Jersey. Det finns ytterligare ett par som stöds ur rutan.

Det sista vi behöver göra är att konfigurera Jersey i 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>

Här konfigurerar vi bara Jersey för att använda vår AppConfig klass. En mycket viktig sak att påpeka här är användningen av <filter> istället för vad du vanligtvis skulle se, en <servlet> . Detta krävs när du använder JSP som mallmotor.

Nu kan vi köra det. Från kommandoraden kör mvn jetty:run . Detta kommer att köra Maven Jetty-plugin som vi konfigurerade tidigare. När du ser "Started Jetty Server" är servern klar. Gå till webbläsarens URL http://localhost:8080/ . Voila, "Hej världen". Njut av.

Mer information finns i Jersey-dokumentationen för MVC-mallar

Modified text is an extract of the original Stack Overflow Documentation

Licensierat under CC BY-SA 3.0

Inte anslutet till Stack Overflow

jersey
Jersey MVC Support

Sök…

Introduktion

Jersey MVC Hello World