jersey => Supporto MVC di Jersey

introduzione

I framework MVC come Spring MVC si utilizzano per creare applicazioni Web che servono pagine Web dinamiche. Jersey, anche se noto per essere un framework REST, ha anche il supporto per creare pagine web dinamiche utilizzando il suo modulo MVC.

Jersey MVC Hello World

Per iniziare, crea una nuova webapp Maven (come farlo non rientra nell'ambito di questo esempio). Nel tuo pom.xml, aggiungi le seguenti due dipendenze

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

Inoltre, nel pom, aggiungi il jetty-maven-plugin che utilizzeremo durante l'esecuzione dell'applicazione

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

Ora possiamo creare i nostri controller. In qualsiasi framework MVC, i concetti sono solitamente gli stessi. Si dispone di un modello e si utilizza un controller per popolare un modello che verrà utilizzato per il rendering del modello. Il termine "render" qui è usato per significare creare la pagina HTML finale combinando il modello e il modello Prendi ad esempio questo modello

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

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

Questo è un file JSP. JSP è solo uno dei motori di template supportati da Jersey. Qui stiamo usando due variabili del modello, hello e world . Si prevede che queste due variabili saranno nel modello utilizzato per il rendering di questo modello. Quindi aggiungiamo il controller

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

Puoi vedere qui stiamo popolando il modello con le proprietà hello e world . Anche il metodo controller restituisce il nome del modello di vista che deve essere utilizzato, in questo caso index . Con questo il framework sa afferrare il modello "index" e utilizzare il modello fornito per renderlo.

Ora dobbiamo solo configurarlo. Aggiungi una sottoclasse ResourceConfig con il seguente

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

Ci sono tre cose che succedono qui:

Utilizziamo i packages per dire a Jersey di analizzare il pacchetto com.example.controller per le classi annotate con @Path in modo che possa registrarlo. In questo caso, registra il nostro HomeController .
Stiamo impostando il percorso di base per il framework per risolvere i template. In questo caso, stiamo dicendo a Jersey di cercare nel WEB-INF/jsp modelli. Puoi vedere l'esempio index.jsp alto in questo director. Anche nel controller restituiamo solo l' index nome del modello. Questo verrà utilizzato per trovare il modello, con il prefisso del percorso di configurazione della configurazione e il suffisso di un .jsp implicito
Abbiamo bisogno di registrare la funzione che gestisce il rendering JSP. Come accennato in precedenza, JSP non è l'unico motore di rendering supportato da Jersey. Ci sono un paio di più supportati fuori dalla scatola.

L'ultima cosa che dobbiamo fare è configurare Jersey nel 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>

Qui stiamo solo configurando Jersey per utilizzare la nostra classe AppConfig . Una cosa molto importante da sottolineare qui è l'uso del <filter> posto di ciò che si vedrebbe normalmente, un <servlet> . Questo è richiesto quando si usa JSP come motore di template.

Ora possiamo eseguirlo. Dalla riga di comando eseguire mvn jetty:run . Questo eseguirà il plugin Maven Jetty che abbiamo configurato in precedenza. Quando vedi "Started Jetty Server", il server è pronto. Vai all'URL del browser http://localhost:8080/ . Voila, "Ciao mondo". Godere.

Per ulteriori informazioni, consultare la documentazione di Jersey per i modelli MVC

Modified text is an extract of the original Stack Overflow Documentation

Autorizzato sotto CC BY-SA 3.0

Non affiliato con Stack Overflow

jersey
Supporto MVC di Jersey

Ricerca…

introduzione

Jersey MVC Hello World