jersey => Ayuda de Jersey MVC

Introducción

MVC Frameworks, como Spring MVC, se utilizan para crear aplicaciones web que sirven páginas web dinámicas. Jersey, aunque se sabe que es un marco REST, también tiene soporte para crear páginas web dinámicas utilizando su módulo MVC.

Jersey MVC Hello World

Para comenzar, cree una nueva aplicación web de Maven (cómo hacerlo está fuera del alcance de este ejemplo). En su pom.xml, agregue las siguientes dos dependencias

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

También en el pom, agregue el jetty-maven-plugin que jetty-maven-plugin ejecutar la aplicación durante el desarrollo

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

Ahora podemos crear nuestros controladores. En cualquier marco MVC, los conceptos son generalmente los mismos. Tiene una plantilla y utiliza un controlador para rellenar un modelo que se utilizará para representar la plantilla. El término "renderizar" aquí se usa para significar crear la página HTML final combinando la plantilla y el modelo Tome, por ejemplo, esta plantilla

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

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

Este es un archivo JSP. JSP es solo uno de los motores de plantillas soportados por Jersey. Aquí estamos usando dos variables de modelo, hello y world . Se espera que estas dos variables estén en el modelo que se utiliza para representar esta plantilla. Así que vamos a agregar el controlador

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

Puedes ver aquí que estamos poblando el modelo con las propiedades hello y world . Además, el método del controlador devuelve el nombre de la plantilla de vista que se va a utilizar, en este caso index . Con esto, el marco sabe que debe tomar la plantilla de "índice" y usar el modelo proporcionado para representarlo.

Ahora solo necesitamos configurarlo. Agregue una subclase ResourceConfig con lo siguiente

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

Hay tres cosas que suceden aquí:

Usamos packages para decirle a Jersey que escanee el paquete com.example.controller para las clases anotadas con @Path para que pueda registrarlo. En este caso, registra nuestro HomeController .
Estamos configurando la ruta base para que el marco resuelva las plantillas. En este caso, le estamos diciendo a Jersey que busque plantillas en WEB-INF/jsp . Puede ver el ejemplo de index.jsp anterior en este director. También en el controlador devolvemos solo el index nombre de la plantilla. Esto se usará para encontrar la plantilla, prefijando la ruta de configuración de la base y colocando un sufijo implícito en .jsp
Necesitamos registrar la característica que maneja el renderizado JSP. Como se mencionó anteriormente, JSP no es el único motor de renderizado soportado por Jersey. Hay un par más apoyado fuera de la caja.

Lo último que debemos hacer es configurar Jersey en el 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>

Aquí solo estamos configurando Jersey para usar nuestra clase AppConfig . Una cosa muy importante a destacar aquí es el uso del <filter> lugar de lo que normalmente vería, un <servlet> . Esto es necesario cuando se utiliza JSP como motor de plantillas.

Ahora podemos ejecutarlo. Desde la línea de comandos ejecuta mvn jetty:run . Esto ejecutará el complemento Maven Jetty que configuramos previamente. Cuando vea "Started Jetty Server", el servidor estará listo. Vaya a la URL del navegador http://localhost:8080/ . Voila, "Hola Mundo". Disfrutar.

Para obtener más información, consulte la documentación de Jersey para plantillas MVC.

Modified text is an extract of the original Stack Overflow Documentation

Licenciado bajo CC BY-SA 3.0

No afiliado a Stack Overflow

jersey
Ayuda de Jersey MVC

Buscar..

Introducción

Jersey MVC Hello World