jersey => Wsparcie Jersey MVC

Wprowadzenie

Struktury MVC, takie jak Spring MVC, używają do tworzenia aplikacji internetowych obsługujących dynamiczne strony internetowe. Jersey, choć znany jako REST Framework, obsługuje także tworzenie dynamicznych stron internetowych za pomocą modułu MVC.

Jersey MVC Hello World

Aby rozpocząć, utwórz nową aplikację internetową Maven (jak to zrobić jest poza zakresem tego przykładu). W pom.xml dodaj następujące dwie zależności

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

Również w pom, dodaj jetty-maven-plugin , że będziemy używać uruchamiania aplikacji podczas programowania

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

Teraz możemy stworzyć nasze kontrolery. W każdym frameworku MVC koncepcje są zwykle takie same. Masz szablon i używasz kontrolera do wypełnienia modelu, który będzie używany do renderowania szablonu. Termin „renderowanie” oznacza tutaj utworzenie ostatecznej strony HTML poprzez połączenie szablonu i modelu Weźmy na przykład ten szablon

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

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

To jest plik JSP. JSP to tylko jeden z silników szablonów obsługiwanych przez Jersey. Tutaj używamy dwóch zmiennych modelu, hello i world . Oczekuje się, że te dwie zmienne znajdą się w modelu używanym do renderowania tego szablonu. Dodajmy więc kontroler

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

Widać tutaj, że wypełniamy model właściwościami hello i world . Również metoda kontrolera zwraca nazwę szablonu widoku, który ma być użyty, w tym przypadku index . Dzięki temu środowisko wie, jak pobrać szablon „indeksu” i użyć dostarczonego modelu do jego renderowania.

Teraz musimy go tylko skonfigurować. Dodaj podklasę ResourceConfig z następującymi elementami

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

Działają się tutaj trzy rzeczy:

Używamy packages aby powiedzieć @Path aby zeskanował pakiet com.example.controller poszukiwaniu klas z adnotacją @Path aby mógł go zarejestrować. W takim przypadku rejestruje nasz HomeController .
Ustalamy podstawową ścieżkę dla środowiska do rozwiązywania szablonów. W tym przypadku mówimy Jersey, aby WEB-INF/jsp szablonów w WEB-INF/jsp . Możesz zobaczyć przykład index.jsp powyżej w tym reżyserze. Również w kontrolerze zwracamy tylko index nazw szablonów. Zostanie on użyty do znalezienia szablonu, poprzedzając prefiks konfiguracji podstawowej ścieżki i dodając niejawny .jsp
Musimy zarejestrować funkcję, która obsługuje renderowanie JSP. Jak wspomniano wcześniej, JSP nie jest jedynym silnikiem renderującym obsługiwanym przez Jersey. Istnieje kilka innych obsługiwanych po wyjęciu z pudełka.

Ostatnią rzeczą, którą musimy zrobić, to skonfigurować Jersey w pliku 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>

Właśnie konfigurujemy Jersey do korzystania z naszej klasy AppConfig . Jedną bardzo ważną rzeczą, na którą warto tutaj zwrócić uwagę, jest użycie <filter> zamiast tego, co normalnie byś widział, <servlet> . Jest to wymagane, gdy używasz JSP jako silnika szablonów.

Teraz możemy to uruchomić. Z wiersza polecenia uruchom mvn jetty:run . Spowoduje to uruchomienie skonfigurowanej wcześniej wtyczki Maven Jetty. Gdy zobaczysz komunikat „Uruchomiono Jetty Server”, serwer jest gotowy. Przejdź do adresu URL przeglądarki http://localhost:8080/ . Voila, „Hello World”. Cieszyć się.

Aby uzyskać więcej informacji, zobacz dokumentację Jersey dotyczącą szablonów MVC

Modified text is an extract of the original Stack Overflow Documentation

Licencjonowany na podstawie CC BY-SA 3.0

Nie związany z Stack Overflow

jersey
Wsparcie Jersey MVC

Szukaj…

Wprowadzenie

Jersey MVC Hello World