jersey => Jersey MVC Support

Introduction

Les cadres MVC, tels que Spring MVC, permettent de créer des applications Web servant des pages Web dynamiques. Jersey, bien que connu pour être un framework REST, prend également en charge la création de pages Web dynamiques à l'aide de son module MVC.

Jersey MVC Hello World

Pour commencer, créez une nouvelle application Web Maven (comment faire cela en dehors du cadre de cet exemple). Dans votre pom.xml, ajoutez les deux dépendances suivantes

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

Aussi dans le pom, ajoutez le jetty-maven-plugin que nous allons utiliser pour exécuter l'application pendant le développement

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

Maintenant, nous pouvons créer nos contrôleurs. Dans tout framework MVC, les concepts sont généralement les mêmes. Vous avez un modèle et vous utilisez un contrôleur pour remplir un modèle qui sera utilisé pour rendre le modèle. Le terme "rendre" signifie ici créer la page HTML finale en combinant le modèle et le modèle. Prenons par exemple ce modèle.

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

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

Ceci est un fichier JSP. JSP n'est qu'un des moteurs de modèles pris en charge par Jersey. Nous utilisons ici deux variables de modèle, hello et world . On s'attend à ce que ces deux variables soient dans le modèle utilisé pour rendre ce modèle. Alors ajoutons le contrôleur

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

Vous pouvez voir ici que nous remplissons le modèle avec les propriétés hello et world . En outre, la méthode controller renvoie le nom du modèle de vue à utiliser, dans cet index . Avec cela, le framework sait récupérer le modèle "index" et utiliser le modèle fourni pour le rendre.

Maintenant, il suffit de le configurer. Ajouter une sous-classe ResourceConfig avec les éléments suivants

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

Il y a trois choses ici:

Nous utilisons des packages pour dire Jersey pour analyser le com.example.controller package pour les classes annotées avec @Path pour qu'il puisse enregistrer. Dans ce cas, il enregistre notre HomeController .
Nous définissons le chemin de base du framework pour résoudre les templates. Dans ce cas, nous disons à Jersey de rechercher dans le WEB-INF/jsp des modèles. Vous pouvez voir l'exemple index.jsp ci-dessus dans ce directeur. Dans le contrôleur, nous renvoyons uniquement l' index nom du modèle. Ceci sera utilisé pour trouver le modèle, en préfixant le chemin de base de configuration et en ajoutant un suffixe .jsp implicite .jsp
Nous devons enregistrer la fonctionnalité qui gère le rendu JSP. Comme mentionné précédemment, JSP n'est pas le seul moteur de rendu pris en charge par Jersey. Il y a un couple de plus supporté hors de la boîte.

La dernière chose à faire est de configurer Jersey dans le 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>

Ici, nous ne faisons que configurer Jersey pour utiliser notre classe AppConfig . Une chose très importante à souligner ici est l'utilisation du <filter> au lieu de ce que vous verriez normalement, un <servlet> . Cela est nécessaire lorsque vous utilisez JSP comme moteur de modèle.

Maintenant, nous pouvons l'exécuter. À partir de la ligne de commande, exécutez mvn jetty:run . Cela exécutera le plugin Maven Jetty que nous avons configuré précédemment. Lorsque vous voyez "Serveur Jetty démarré", le serveur est prêt. Accédez à l'URL du navigateur http://localhost:8080/ . Voila, "Hello World". Prendre plaisir.

Pour plus d'informations, consultez la documentation de Jersey pour les modèles MVC.

Modified text is an extract of the original Stack Overflow Documentation

Sous licence CC BY-SA 3.0

Non affilié à Stack Overflow

jersey
Jersey MVC Support

Recherche…

Introduction

Jersey MVC Hello World