Jersey MVC templating support is provided by Jersey as a set of (three) extension modules:

If you want to use just templating API infrastructure provided by Jersey for the MVC templating support in order to implement your custom support for a templating engine other than the ones provided by Jersey (JSP/Freemarker), you will need to add the base jersey-mvc module into the list of your dependencies:

<dependency>
    <groupId>org.glassfish.jersey.ext</groupId>
    <artifactId>jersey-mvc</artifactId>
    <version>2.1</version>
</dependency>

To use one of the templating engines for which Jersey provides the integration implementation (JSP/Freemarker) in your project, you need to add the jersey-mvc-jsp or jersey-mvc-freemarker module to your pom.xml respectively:

<dependency>
    <groupId>org.glassfish.jersey.ext</groupId>
    <artifactId>jersey-mvc-jsp</artifactId>
    <version>2.1</version>
</dependency>

<dependency>
    <groupId>org.glassfish.jersey.ext</groupId>
    <artifactId>jersey-mvc-freemarker</artifactId>
    <version>2.1</version>
</dependency>

Both of these modules transitively depend on the base jersey-mvc, so it is not necessary to add the base jersey-mvc module explicitly into your dependency list, however it is a recommended Maven practice to do so.

If you are not using Maven you need to make sure to have all required transitive dependencies (see jersey-mvc/jersey-mvc-freemarker/jersey-mvc-jsp) on the classpath.

To use capabilities of Jersey MVC templating support in your JAX-RS/Jersey application you need to register Features provided by the modules mentioned above. For jersey-mvc it is MvcFeature, for jersey-mvc-jsp it's JspMvcFeature and for jersey-mvc-freemarker it is FreemarkerMvcFeature.

new ResourceConfig()
    .register(org.glassfish.jersey.server.mvc.MvcFeature.class)
    // Further configuration of ResourceConfig.
    .register( ... );

new ResourceConfig()
    .register(org.glassfish.jersey.server.mvc.jsp.JspMvcFeature.class)
    // Further configuration of ResourceConfig.
    .register( ... );

Each of the three MVC modules contains a *Properties (e.g. FreemarkerMvcProperties) file which defines a set of properties that could be set in a JAX-RS Application / ResourceConfig in order to take effect, see the Example 17.3, “Setting MvcProperties.TEMPLATE_BASE_PATH value in ResourceConfig” and Example 17.4, “Setting FreemarkerMvcProperties.TEMPLATE_BASE_PATH value in web.xml”.

Following list contains description of the available properties:

new ResourceConfig()
    .property(MvcProperties.TEMPLATE_BASE_PATH, "templates")
    .register(MvcFeature.class)
    // Further configuration of ResourceConfig.
    .register( ... );

<servlet>
    <servlet-name>org.glassfish.jersey.examples.freemarker.MyApplication</servlet-name>
    <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
    <init-param>
        <param-name>javax.ws.rs.Application</param-name>
        <param-value>org.glassfish.jersey.examples.freemarker.MyApplication</param-value>
    </init-param>
    <init-param>
        <param-name>jersey.config.server.mvc.templateBasePath.freemarker</param-name>
        <param-value>freemarker</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

In Jersey 2.0, the base MVC API (excluding the SPI part) consists of two classes (in the org.glassfish.jersey.server.mvc package in base MVC module) that we will explore in more detail now, namely Viewable and @Template. These classes determines which approach (explicit/implicit) you would be taking when working with Jersey MVC templating support.

package com.foo;

@Path("foo")
public class Foo {

    @GET
    public Viewable get() {
        return new Viewable("index", "FOO");
    }
}

"/com/foo/Foo/index"

@GET
public Viewable get() {
    return new Viewable("/index", "FOO");
}

@Path("foo")
@Template
public class Foo {

    public String getFoo() {
        return "FOO";
    }
}

@GET
public Viewable get() {
    return new Viewable("index", this);
}

@GET
                        @Path("{implicit-view-path-parameter}")
                        public Viewable get(@PathParameter("{implicit-view-path-parameter}") String template) {
                        return new Viewable(template, this);
                        }

As stated earlier, Jersey provides support for JSP templates in jersey-mvc-jsp extension module. There is a JSP template processor that resolves absolute template references to processable template references represented as JSP pages as follows:

Thus the absolute template reference "/com/foo/Foo/index" would be resolved to "/com/foo/Foo/index.jsp", provided there exists a "/com/foo/Foo/index.jsp" JSP page in the web application.

Jersey will assign the model instance to the attribute named "it". So in the case of the implicit example it is possible to referece the foo property on the Foo resource from the JSP template as follows:

<h1>${it.foo}</h1>

To add support for other (custom) templating engines into Jersey MVC Templating facility, you need to implement the TemplateProcessor and register this class into your application.

@Provider
class MyTemplateProcessor implements TemplateProcessor<String> {

    @Override
    public String resolve(String path, final MediaType mediaType) {
        final String extension = ".testp";

        if (!path.endsWith(extension)) {
            path = path + extension;
        }

        final URL u = this.getClass().getResource(path);
        return u == null ? null : path;
    }

    @Override
    public void writeTo(String templateReference,
                        Viewable viewable,
                        MediaType mediaType,
                        OutputStream out) throws IOException {
        final PrintStream ps = new PrintStream(out);
        ps.print("path=");
        ps.print(templateReference);
        ps.println();
        ps.print("model=");
        ps.print(viewable.getModel().toString());
        ps.println();
    }

}

new ResourceConfig()
    .register(MyTemplateProcessor.class)
    // Further configuration of ResourceConfig.
    .register( ... );

To see an example of MVC (JSP) templating support in Jersey refer to the MVC (Bookstore) example.