JAX-RS @Context

last modified January 10, 2023

JAX-RS @Context tutorial shows how use the @Context annotation in a RESTful Java web application with Jersey framework.

Jersey

Jersey is a framework for developing RESTful Web Services in Java. It is a reference implementation of the Java API for RESTful Web Services (JAX-RS) specification. Another popular JAX-RS implementation is JBoss’ RESTEasy.

JAX-RS @Context

The JAX-RS @Context annotation allows to inject context related information into a class field, bean property or method parameter.

JAX-RS @Context example

The following example is a simple RESTful application, which returns some context related data to the client as plain text.

├── pom.xml └── src ├── main │ ├── java │ │ └── com │ │ └── zetcode │ │ ├── conf │ │ │ └── ApplicationConfig.java │ │ └── ws │ │ └── MyResource.java │ ├── resources │ └── webapp │ └── META-INF │ └── context.xml └── test └── java

This is the project structure.

pom.xml

<?xml version=“1.0” encoding=“UTF-8”?> <project xmlns=“http://maven.apache.org/POM/4.0.0" xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=“http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

<modelVersion>4.0.0</modelVersion>

<groupId>com.zetcode</groupId>
<artifactId>JerseyContext</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>

<name>JerseyContext</name>

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
</properties>

<dependencies>
    <dependency>
        <groupId>org.glassfish.jersey.containers</groupId>
        <artifactId>jersey-container-servlet</artifactId>
        <version>2.25</version>
    </dependency>
    
    <dependency>
        <groupId>org.glassfish.jersey.core</groupId>
        <artifactId>jersey-server</artifactId>
        <version>2.25</version>
    </dependency>
    
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.0</version>
        <scope>provided</scope>
    </dependency>        
    
</dependencies>

<build>
    <plugins>
        
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-war-plugin</artifactId>
            <version>2.3</version>
            <configuration>
                <failOnMissingWebXml>false</failOnMissingWebXml>
            </configuration>
        </plugin>

    </plugins>
</build>

</project>

This is the Maven POM file. It contains the jersey-container-servlet, jersey-server, and javax.servlet dependencies.

context.xml

<?xml version=“1.0” encoding=“UTF-8”?> <Context path="/JerseyContext”/>

In the Tomcat’s context.xml configuration file, we define the application context path.

ApplicationConfig.java

package com.zetcode.conf;

import com.zetcode.ws.HelloResource; import java.util.HashSet; import java.util.Set; import javax.ws.rs.ApplicationPath; import javax.ws.rs.core.Application;

@ApplicationPath(“rest”) public class ApplicationConfig extends Application {

@Override
public Set<Class<?>> getClasses() {
    Set<Class<?>> set = new HashSet<>();
    set.add(MyResource.class);
    return set;
}

}

This is the application configuration class. Since Servlet 3.0 it is possible to deploy application without the web.xml file. The Application defines the components of a JAX-RS application and supplies additional meta-data. Here we register resource classes, providers, or properties the application needs.

@ApplicationPath(“rest”)

With the @ApplicationPath annotation, we set the path to RESTful web services.

@Override public Set<Class<?>> getClasses() { Set<Class<?>> set = new HashSet<>(); set.add(MyResource.class); return set; }

Inside the getClasses method, we add the resource classes. In our case, we have one MyResource class.

MyResource.java

package com.zetcode.ws;

import javax.inject.Inject; import javax.servlet.ServletContext; import javax.servlet.http.HttpServletRequest; import javax.ws.rs.GET; import javax.ws.rs.Path; import javax.ws.rs.Produces; import javax.ws.rs.core.Context; import javax.ws.rs.core.MediaType; import javax.ws.rs.core.Response; import javax.ws.rs.core.UriInfo;

@Path(“myresource”) public class MyResource {

@Context
private UriInfo info;

@Context
private HttpServletRequest servletRequest;    

@Context 
private ServletContext servletContext;

@GET
@Produces(MediaType.TEXT_PLAIN)
public Response message() {

    StringBuilder builder = new StringBuilder();
    
    String baseUri = info.getBaseUri().toASCIIString();
    String method = servletRequest.getMethod();
    String serverInfo = servletContext.getServerInfo();
    
    builder.append("Base uri: ").append(baseUri)
            .append("; HTTP method: ").append(method)
            .append("; Server info: ").append(serverInfo);
    
    String output = builder.toString();
    
    return Response.status(200).entity(output).build();
}

}

This is the MyResource class.

@Path(“myresource”) public class MyResource {

The @Path specifies the URL to which the resource responds.

@Context private UriInfo info;

@Context private HttpServletRequest servletRequest;

@Context private ServletContext servletContext;

Here we inject UriInfo, HttpServletRequest, and ServletContext into class fields with @Context.

@GET @Produces(MediaType.TEXT_PLAIN) public Response message() {

The @GET annotation indicates that the annotated method responds to HTTP GET requests. With the @Produces annotation, we define that the method produces plain text.

StringBuilder builder = new StringBuilder();

String baseUri = info.getBaseUri().toASCIIString(); String method = servletRequest.getMethod(); String serverInfo = servletContext.getServerInfo();

builder.append(“Base uri: “).append(baseUri) .append(”; HTTP method: “).append(method) .append(”; Server info: “).append(serverInfo);

String output = builder.toString();

From the injected classes, we get the base URI, HTTP method, and server info. We build an output from the gathered information.

return Response.status(200).entity(output).build();

We send a response containing the information to the client.

$ curl localhost:8084/JerseyContext/rest/myresource Base uri: http://localhost:8084/JerseyContext/rest/; HTTP method: GET; Server info: Apache Tomcat/8.0.27

After the application is deployed on Tomcat, we send a GET request to the application with curl.

In this tutorial, we have used the JAX-RS @Context annotation.