Jersey

https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/
Admin
Jersey is a Java framework for building RESTful web applications and services using JAX-RS,...
Tokens:230,323
Snippets:2,717
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Start OSGi Bundle

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/deployment.html

Start an installed OSGi bundle using its Bundle ID. Ensure you use the correct ID obtained from the 'install' command.

```bash
start 303
```

--------------------------------

### Run HelloWorld Native Image Generation

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/graalvm-native-image.html

Command to package the Jersey examples' helloworld application for native image generation. Assumes GraalVM is installed and configured.

```bash
mvn -Pnative-image clean package -DskipTests
```

--------------------------------

### JAX-RS Client API Example

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/client.html

Demonstrates setting up a client configuration, registering filters, building a web target, setting query parameters, and making a GET request, then processing the response.

```java
ClientConfig clientConfig = new ClientConfig();
clientConfig.register(MyClientResponseFilter.class);
clientConfig.register(new AnotherClientFilter());
Client client = ClientBuilder.newClient(clientConfig);
client.register(ThirdClientFilter.class);
WebTarget webTarget = client.target("http://example.com/rest");
webTarget.register(FilterForExampleCom.class);
WebTarget resourceWebTarget = webTarget.path("resource");
WebTarget helloworldWebTarget = resourceWebTarget.path("helloworld");
WebTarget helloworldWebTargetWithQueryParam = helloworldWebTarget.queryParam("greeting", "Hi World!");
Invocation.Builder invocationBuilder = helloworldWebTargetWithQueryParam.request(MediaType.TEXT_PLAIN_TYPE);
invocationBuilder.header("some-header", "true");
Response response = invocationBuilder.get();
System.out.println(response.getStatus());
System.out.println(response.readEntity(String.class));
```

--------------------------------

### Create a Simple Client Instance

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

Use ClientBuilder.newClient() to create a basic JAX-RS Client instance. This is the most straightforward way to get started.

```java
Client client = ClientBuilder.newClient();
```

--------------------------------

### Install OSGi Bundle into Runtime

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

Install the OSGi bundle into the OSGi runtime using the 'install' command. Replace 'file:///path/to/file/bundle.jar' with the actual path to your bundle.

```bash
install file:///path/to/file/bundle.jar
```

--------------------------------

### Install OSGi Bundle from Local File

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/deployment.html

Install a pre-built OSGi bundle JAR file into the OSGi runtime using the Gogo shell. Replace 'file:///path/to/file/bundle.jar' with the actual path to your bundle.

```bash
install file:///path/to/file/bundle.jar
```

--------------------------------

### HelloWorld Native Image Output

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

This is the expected console output after running the generated native image of the Jersey helloworld example. It indicates the application has started and provides a URL to access it.

```text
                "Hello World" Jersey Example App
                May 27, 2021 1:37:49 PM org.glassfish.jersey.server.wadl.WadlFeature configure
                WARNING: JAX-B API not found . WADL feature is disabled.
                May 27, 2021 1:37:49 PM org.glassfish.grizzly.http.server.NetworkListener start
                INFO: Started listener bound to [localhost:8080]
                May 27, 2021 1:37:49 PM org.glassfish.grizzly.http.server.HttpServer start
                INFO: [HttpServer] Started.
                Application started.
                Try out http://localhost:8080/base/helloworld
                Stop the application using CTRL+C
            
```

--------------------------------

### Programmatic Hello World Resource with Jersey API

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

Implements a JAX-RS resource programmatically using Jersey's Resource.Builder and ResourceMethod.Builder. This example defines a GET method that returns 'Hello World!' via an Inflector.

```Java
package org.glassfish.jersey.examples.helloworld;
import jakarta.ws.rs.container.ContainerRequestContext;
import jakarta.ws.rs.core.Application;
import jakarta.ws.rs.core.Response;
import org.glassfish.jersey.process.Inflector;
import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.server.model.Resource;
import org.glassfish.jersey.server.model.ResourceMethod;
public static class MyResourceConfig extends ResourceConfig {
    public MyResourceConfig() {
        final Resource.Builder resourceBuilder = Resource.builder();
        resourceBuilder.path("helloworld");
        final ResourceMethod.Builder methodBuilder = resourceBuilder.addMethod("GET");
        methodBuilder.produces(MediaType.TEXT_PLAIN_TYPE)
                     .handledBy(new Inflector<ContainerRequestContext, String>() {
            @Override
            public String apply(ContainerRequestContext containerRequestContext) {
                return "Hello World!";
            }
        });
        final Resource resource = resourceBuilder.build();
        registerResources(resource);
    }
}
```

--------------------------------

### Configure and Start Netty HTTP Server with Jersey

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

This snippet demonstrates how to create a Jersey application and start it using the Netty HTTP server. Include the jersey-container-netty-http dependency.

```Java
URI baseUri = UriBuilder.fromUri("http://localhost/").port(9998).build();
ResourceConfig resourceConfig = new ResourceConfig(HelloWorldResource.class);
Channel server = NettyHttpContainerProvider.createServer(baseUri, resourceConfig, false);
```

```XML
<dependency>
    <groupId>org.glassfish.jersey.containers</groupId>
    <artifactId>jersey-container-netty-http</artifactId>
    <version>3.1.1</version>
</dependency>
```

--------------------------------

### Start Jakarta REST Application with SeBootstrap

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

Starts a Jakarta REST application using the SeBootstrap API and WebServer SPI for SE deployment. Requires an MyApplication instance and configuration builder.

```java
Application application = new MyApplication();
SeBootstrap.Configuration.Builder configBuilder = SeBootstrap.Configuration.builder();
WebServer webServer = WebServerFactory.createServer(WebServer.class, application, configBuilder.build());
```

--------------------------------

### Configure and Start Jetty HTTP Server with Jersey

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

This snippet shows how to create a Jersey application and start it using the Jetty HTTP server. Ensure the jersey-container-jetty-http dependency is included.

```Java
URI baseUri = UriBuilder.fromUri("http://localhost/").port(9998).build();
ResourceConfig config = new ResourceConfig(MyResource.class);
Server server = JettyHttpContainerFactory.createServer(baseUri, config);
```

```XML
<dependency>
    <groupId>org.glassfish.jersey.containers</groupId>
    <artifactId>jersey-container-jetty-http</artifactId>
    <version>3.1.1</version>
</dependency>
```

--------------------------------

### Badgerfish JSON output example

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/media.html

Example of JSON output produced using the Badgerfish notation.

```json
{
   "contact":{
      "id":{
         "$":"2"
      },
      "name":{
         "$":"Bob"
      },
      "addresses":{
         "street":{
            "$":"Long Street 1"
         },
         "town":{
            "$":"Short Village"
         }
      }
   }
}
```

--------------------------------

### JAXB Bean Initialization for JSON Examples

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

Initializes JAXB beans (Address and Contact) for demonstrating JSON notation examples.

```java
Address[] addresses = {
new Address("Long Street 1", "Short Village")};
Contact contact = new Contact(2, "Bob", Arrays.asList(addresses));
```

--------------------------------

### JAXB Bean Initialization Example

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/media.html

Initializes a Contact bean with an Address, demonstrating the structure used for JSON notation examples.

```java
Address[] addresses = {new Address("Long Street 1", "Short Village")};
Contact contact = new Contact(2, "Bob", Arrays.asList(addresses));
```

--------------------------------

### Install OSGi Bundle from Maven Repository

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/deployment.html

Install an OSGi bundle directly from the Maven repository. Ensure you replace '<version>' with the correct version number compatible with your GlassFish instance.

```bash
install https://repo1.maven.org/maven2/org/glassfish/jersey/examples/osgi-http-service/bundle/<version>/bundle-<version>.jar
```

--------------------------------

### Start a Jakarta REST Application with SeBootstrap

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

This snippet shows the basic usage of the SeBootstrap API to start a Jakarta REST application in a Java SE environment. An Application instance and configuration builder are required.

```Java
Application application = new MyApplication();
SeBootstrap.Configuration.Builder configBuilder = SeBootstrap.Configuration.builder();
CompletionStage<SeBootstrap.Instance> completionStage = SeBootstrap.start(application, configBuilder.build());
```

--------------------------------

### Registering SPI Implementations using ResourceConfig subclass

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

This example demonstrates how to achieve the same application configuration as Example 4.3 when extending the Application subclass, typically used in Servlet container deployments. It disables service provider lookup and manually registers SPI implementations.

```java
public class MyApplication extends ResourceConfig {
    public MyApplication() {
        register(org.glassfish.jersey.server.filter.UriConnegFilter.class);
        register(org.glassfish.jersey.server.validation.ValidationFeature.class);
        register(org.glassfish.jersey.server.spring.SpringComponentProvider.class);
        register(org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpContainerProvider.class);
        property(ServerProperties.METAINF_SERVICES_LOOKUP_DISABLE, true);
    }
}
```

--------------------------------

### Configure OSGi Shell Start Level in osgi.properties

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

Sets the final start level for the OSGi framework in GlassFish by modifying the 'osgi.properties' file.

```properties
# Final start level of OSGi framework. This is used by GlassFish launcher code
# to set the start level of the OSGi framework once server is up and running so that
# optional services can start. The initial start level of framework is controlled using
# the standard framework property called org.osgi.framework.startlevel.beginning
glassfish.osgi.start.level.final=3
```

--------------------------------

### Server-Side Logging Example Output

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

Example log output demonstrating server-side request and response logging with entity payload. Shows request details, response status, and entity content.

```log
1 May 09, 2020 2:55:33 PM org.glassfish.jersey.logging.LoggingInterceptor log
2 INFO: 1 * Server has received a request on thread grizzly-http-server-0
3 1 > GET http://localhost:9998/helloworld
4 1 > accept: text/plain
5 1 > accept-encoding: gzip,deflate
6 1 > connection: Keep-Alive
7 1 > host: localhost:9998
8 1 > user-agent: Jersey/3.0.0 (Apache HttpClient 4.5.9)
9 
10 May 09, 2020 2:55:33 PM org.glassfish.jersey.logging.LoggingInterceptor log
11 INFO: 1 * Server responded with a response on thread grizzly-http-server-0
12 1 < 200
13 1 < Content-Type: text/plain
14 Hello World!
```

--------------------------------

### Basic Jersey Test Setup

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/test-framework.html

This snippet demonstrates a basic test setup using JerseyTest. It includes a simple resource class and configures the test application using ResourceConfig. Use this for straightforward REST endpoint testing.

```java
public class SimpleTest extends JerseyTest {
    @Path("hello")
    public static class HelloResource {
        @GET
        public String getHello() {
            return "Hello World!";
        }
    }
    @Override
    protected Application configure() {
        return new ResourceConfig(HelloResource.class);
    }
    @Test
    public void test() {
        final String hello = target("hello").request().get(String.class);
        assertEquals("Hello World!", hello);
    }
}
```

--------------------------------

### Select WebServer implementation

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/deployment.html

Demonstrates how to specify a concrete WebServer implementation class or use a specific WebServerProvider.

```java
WebServer webServer = WebServerFactory.createServer(GrizzlyHttpServer.class, application, configBuilder.build());
```

```java
WebServer webServer = GrizzlyHttpServerProvider.createServer(WebServer.class, application, configBuilder.build());
```

--------------------------------

### Example Resource Class

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/index.html

A basic JAX-RS resource class with a GET method.

```java
@Path("resources")
public class ExampleResource {

    @GET
    @Path("/{id}")
    public String getResource(@PathParam("id") String id) {
        return "Resource with id: " + id;
    }
}
```

--------------------------------

### Example JAX-RS Resource Class

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

Defines a JAX-RS resource with GET and POST methods that handle a custom entity bean.

```java
@Path("resource")
public class MyResource {
    @GET
    @Produces("application/xml")
    public MyBean getMyBean() {
        return new MyBean("Hello World!", 42);
    }
    @POST
    @Consumes("application/xml")
    public String postMyBean(MyBean myBean) {
        return myBean.anyString;
    }
}
```

--------------------------------

### Simple WADL Example - JAX-RS Resource Definition

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/index.html

Define a JAX-RS resource that can generate a Web Application Description Language (WADL) document. This example shows a basic resource method returning WADL content.

```java
@Path("/application.wadl")
public class WadlResource {

    @GET
    @Produces({"application/xml", "application/vnd.sun.wadl+xml"})
    public String getApplicationWadl() {
        // WADL content generation logic here
        return "<application xmlns=\"http://wadl.dev.java.net/2009/02\"/>";
    }
}
```

--------------------------------

### Invoke JAX-RS Client Requests

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/monitoring_tracing.html

Example of using WebTarget to perform GET and POST requests to trigger application events.

```java
target.path("resource").request()    .post(Entity.entity("post", MediaType.TEXT_PLAIN_TYPE));    target.path("resource").request().get();
```

--------------------------------

### Maven Build Output

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/getting-started.html

Example of a successful build output showing the packaging process for the WAR file.

```text
Results :

Tests run: 0, Failures: 0, Errors: 0, Skipped: 0

[INFO]
[INFO] --- maven-war-plugin:2.2:war (default-war) @ simple-service-webapp ---
[INFO] Packaging webapp
[INFO] Assembling webapp [simple-service-webapp] in
[.../simple-service-webapp/target/simple-service-webapp]
[INFO] Processing war project
[INFO] Copying webapp resources [.../simple-service-webapp/src/main/webapp]
[INFO] Webapp assembled in [117 msecs]
[INFO] Building war: .../simple-service-webapp/target/simple-service-webapp.war
[INFO] WEB-INF/web.xml already added, skipping
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3.419 s
[INFO] Finished at: 2020-11-25T09:34:59+01:00
[INFO] ------------------------------------------------------------------------
```

--------------------------------

### Perform OAuth Authorization Flow

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

Initiate the OAuth authorization flow by starting it to get the authorization URI, and then finishing it with a verifier code to obtain an access token.

```java
String authorizationUri = authFlow.start();
// here we must direct the user to authorization uri to approve
// our application. The result will be verifier code (String).
AccessToken accessToken = authFlow.finish(verifier);
```

--------------------------------

### Consume XML with JAX-RS Client

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

Example of using a JAX-RS client to make a GET request to a resource that produces XML and deserialize the response into a Planet object.

```java
Planet planet = webTarget.path("planet").request(MediaType.APPLICATION_XML_TYPE).get(Planet.class);
```

--------------------------------

### Deployment with web.xml and Servlet 5.0

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/index.html

Provides an example of a `web.xml` configuration for deploying a JAX-RS application using Servlet 5.0.

```xml
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_5_0.xsd" version="5.0">

    <servlet>
        <servlet-name>Jersey REST Service</servlet-name>
        <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
        <init-param>
            <param-name>javax.ws.rs.Application</param-name>
            <param-value>com.example.MyAppConfig</param-value>
        </init-param>
    </servlet>

    <servlet-mapping>
        <servlet-name>Jersey REST Service</servlet-name>
        <url-pattern>/api/*</url-pattern>
    </servlet-mapping>

</web-app>
```

--------------------------------

### Obtain Flowable<Response> from Jersey/RxJava Client

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/rx-client.html

Example of making an HTTP GET request and obtaining a Flowable<Response>. Similar to Observable, requests are invoked upon subscription.

```java
Flowable<Response> observable = RxObservable.newClient()
            .target("http://example.com/resource")
            .request()
            .rx(RxFlowableInvoker.class)
            .get();
```

--------------------------------

### Using JAX-RS Client API

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

Demonstrates how to configure a client, register filters, build a web target with path and query parameters, set headers, and retrieve a response.

```Java
ClientConfig clientConfig = new ClientConfig();
clientConfig.register(MyClientResponseFilter.class);
clientConfig.register(new AnotherClientFilter());
Client client = ClientBuilder.newClient(clientConfig);
client.register(ThirdClientFilter.class);
WebTarget webTarget = client.target("http://example.com/rest");
webTarget.register(FilterForExampleCom.class);
WebTarget resourceWebTarget = webTarget.path("resource");
WebTarget helloworldWebTarget = resourceWebTarget.path("helloworld");
WebTarget helloworldWebTargetWithQueryParam =            helloworldWebTarget.queryParam("greeting", "Hi World!");
Invocation.Builder invocationBuilder =            helloworldWebTargetWithQueryParam.request(MediaType.TEXT_PLAIN_TYPE);
invocationBuilder.header("some-header", "true");
Response response = invocationBuilder.get();
System.out.println(response.getStatus());
System.out.println(response.readEntity(String.class));
```

--------------------------------

### Initialize Git Repository

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

Initialize an empty Git repository in your project directory. This is the first step before version controlling your application.

```bash
    $ git init
    Initialized empty Git repository in /.../simple-heroku-webapp/.git/
```

--------------------------------

### Obtain Observable<Response> from Jersey/RxJava Client

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/rx-client.html

Example of making an HTTP GET request to a remote service and obtaining an Observable<Response>. The request is invoked when a subscriber subscribes to the observable.

```java
Observable<Response> observable = RxObservable.newClient()
                .target("http://example.com/resource")
                .request()
                .rx(RxObservableInvoker.class)
                .get();
```

--------------------------------

### Initialize a basic Client instance

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/client.html

Use the static ClientBuilder factory method to create a new Client instance.

```java
Client client = ClientBuilder.newClient();
```

--------------------------------

### Example of @JSONP with Configured Parameters

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/index.html

Shows how to configure parameters for the `@JSONP` annotation, such as callback function name and encoding.

```java
@GET
    @Produces(MediaType.APPLICATION_JSON)
    @JSONP(queryParam = "callback", encoding = "UTF-8")
    public JaxbBean getJsonpConfigured() {
        return new JaxbBean();
    }
```

--------------------------------

### TestNG Container Per Method Test Example

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/test-framework.html

Extend JerseyTestNg.ContainerPerMethodTest to create a separate test container for each test method. Setup methods should use @BeforeMethod and teardown methods @AfterMethod.

```java
public class ContainerPerMethodTest extends JerseyTestNg.ContainerPerMethodTest {
    @Path("/")
    @Singleton
    @Produces("text/plain")
    public static class Resource {
        private int i = 1;
        @GET
        public int get() {
            return i++;
        }
    }
    @Override
    protected Application configure() {
        return new ResourceConfig(Resource.class);
    }
    @Test
    public void first() throws Exception {
        test(1);
    }
    @Test
    public void second() throws Exception {
        test(1);
    }
    private void test(final Integer expected) {
        final Response response = target().request().get();
        assertEquals(response.getStatus(), 200);
        assertEquals(response.readEntity(Integer.class), expected);
    }
}
```

--------------------------------

### Initialize Git Repository

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/getting-started.html

Command to initialize a new Git repository in the project directory.

```bash
$ git init
    Initialized empty Git repository in /.../simple-heroku-webapp/.git/
```

--------------------------------

### Configure an existing Client instance

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/client.html

Register additional components on an already created Client instance.

```java
client.register(ThirdClientFilter.class);
```

--------------------------------

### TestNG Container Per Class Test Example

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/test-framework.html

Extend JerseyTestNg.ContainerPerClassTest to create a single test container for all tests within a class. Setup methods should use @BeforeClass and teardown methods @AfterClass.

```java
public class ContainerPerClassTest extends JerseyTestNg.ContainerPerClassTest {
    @Path("/")
    @Singleton
    @Produces("text/plain")
    public static class Resource {
        private int i = 1;
        @GET
        public int get() {
            return i++;
        }
    }
    @Override
    protected Application configure() {
        return new ResourceConfig(Resource.class);
    }
    @Test(priority = 1)
    public void first() throws Exception {
        test(1);
    }
    @Test(priority = 2)
    public void second() throws Exception {
        test(2);
    }
    private void test(final Integer expected) {
        final Response response = target().request().get();
        assertEquals(response.getStatus(), 200);
        assertEquals(response.readEntity(Integer.class), expected);
    }
}
```

--------------------------------

### Create a Client Instance with Configuration

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

Configure a Client instance during creation by passing a ClientConfig object to ClientBuilder.newClient(). This allows for registering custom providers like filters and setting properties.

```java
ClientConfig clientConfig = new ClientConfig();
clientConfig.register(MyClientResponseFilter.class);
clientConfig.register(new AnotherClientFilter());
Client client = ClientBuilder.newClient(clientConfig);
```

--------------------------------

### Implement Request Event Listener in Java

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

Implement the `RequestEventListener` interface to capture and react to various request lifecycle events. This example logs when a resource method starts and when the request finishes, including processing time.

```java
public class MyRequestEventListener implements RequestEventListener {
    private final int requestNumber;
    private final long startTime;

    public MyRequestEventListener(int requestNumber) {
        this.requestNumber = requestNumber;
        startTime = System.currentTimeMillis();
    }

    @Override
    public void onEvent(RequestEvent event) {
        switch (event.getType()) {
            case RESOURCE_METHOD_START:
                System.out.println("Resource method " + event.getUriInfo().getMatchedResourceMethod().getHttpMethod() + " started for request " + requestNumber);
                break;
            case FINISHED:
                System.out.println("Request " + requestNumber + " finished. Processing time " + (System.currentTimeMillis() - startTime) + " ms.");
                break;
        }
    }
}
```

--------------------------------

### ChunkedOutput Example in Jersey

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/async.html

Demonstrates how to return a ChunkedOutput<String> from a resource method. A new thread is started to write chunks to the output, and the method returns immediately. Ensure to close the ChunkedOutput explicitly to end the connection.

```java
@Path("/resource")
public class AsyncResource {
    @GET
    public ChunkedOutput<String> getChunkedResponse() {
        final ChunkedOutput<String> output = new ChunkedOutput<String>(String.class);
        new Thread() {
            public void run() {
                try {
                    String chunk;
                    while ((chunk = getNextString()) != null) {
                        output.write(chunk);
                    }
                } catch (IOException e) {
                    // IOException thrown when writing the
                    // chunks of response: should be handled
                } finally {
                    output.close();
                    // simplified: IOException thrown from
                    // this close() should be handled here...
                }
            }
        }.start();
        // the output will be probably returned even before
        // a first chunk is written by the new thread
        return output;
    }
    private String getNextString() {
        // ... long running operation that returns
        //     next string or null if no other string is accessible
    }
}
```

--------------------------------

### Implicit Sub-Resource Templates with @Template

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

This example demonstrates how Jersey supports implicit sub-resource templates. A @GET @Path sub-resource method can accept a path parameter to specify the template, allowing for dynamic template resolution based on the URL.

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

--------------------------------

### Create Heroku Instance

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/getting-started.html

Command to create a Heroku instance and configure the Git remote.

```bash
$ heroku create
    Creating simple-heroku-webapp... done, stack is cedar
    http://simple-heroku-webapp.herokuapp.com/ | git@heroku.com:simple-heroku-webapp.git
    Git remote heroku added
```

--------------------------------

### Simple Hello World Root Resource Class

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

A basic JAX-RS root resource class annotated with @Path and @GET to produce a plain text 'Hello World!' message. This serves as a fundamental example for creating RESTful web services.

```Java
package org.glassfish.jersey.examples.helloworld;

import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;

@Path("helloworld")
public class HelloWorldResource {
    public static final String CLICHED_MESSAGE = "Hello World!";

    @GET
    @Produces("text/plain")
    public String getHello() {
        return CLICHED_MESSAGE;
    }
}
```

--------------------------------

### Compile and Package WAR

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/getting-started.html

Execute this command to compile the project and package it into a deployable WAR file.

```bash
mvn clean package
```

--------------------------------

### Sub-resource Locators in Jersey

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

Demonstrates sub-resource locators, which are methods annotated with @Path but not with resource method designators (like @GET). These methods return an instance of another resource class, enabling hierarchical routing. This example shows an ItemResource with a locator for ItemContentResource.

```Java
@Path("/item")
public class ItemResource {
    @Context
    UriInfo uriInfo;

    @Path("content")
    public ItemContentResource getItemContentResource() {
        return new ItemContentResource();
    }

    @GET
    @Produces("application/xml")
    public Item get() { ... }
}

public class ItemContentResource {
    @GET
    public Response get() { ... }

    @PUT
    @Path("{version}")
    public void put(@PathParam("version") int version,
                    @Context HttpHeaders headers,
                    byte[] in) {
        ...
    }
}
```

--------------------------------

### Using Jersey with the Simple framework

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/index.html

Shows how to use Jersey with the 'Simple' HTTP server framework.

```java
import org.glassfish.jersey.simple.SimpleContainer;
import org.glassfish.jersey.simple.SimpleServer;
import org.glassfish.jersey.server.ResourceConfig;

public class SimpleServerExample {

    public static void main(String[] args) {
        ResourceConfig config = new ResourceConfig().packages("com.example.resources");
        SimpleServer server = SimpleContainer.create(config);
        server.start();
        System.out.println("Server started with Simple framework.");
        // Server runs until explicitly stopped or application exits
    }
}
```

--------------------------------

### Bootstrap Jersey Application with Weld Support on Grizzly

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/cdi.support.html

This example demonstrates how to bootstrap a Jersey application with Weld support using the Grizzly HTTP container in a Java SE environment. Ensure the Weld container is initialized before starting the HTTP server and shut down properly.

```java
Weld weld = new Weld();
weld.initialize();
final HttpServer server = GrizzlyHttpServerFactory.createHttpServer(URI.create("http://localhost:8080/weld/"), jerseyResourceConfig);
// ...
server.shutdownNow();
weld.shutdown();
```

--------------------------------

### Generated Resource Method for @Template Class

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

This is an example of the default @GET resource method automatically generated by Jersey when a resource class is annotated with @Template without a specific name. It uses Viewable to render the default 'index' template with the resource class instance as the model.

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

--------------------------------

### Sub-resource Methods in Jersey

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

Illustrates how to define sub-resource methods within a root resource class. These methods are annotated with @Path and are selected based on the request URL path after the root resource is matched. This example shows various GET, PUT, and DELETE operations for printer resources.

```Java
@Singleton
@Path("/printers")
public class PrintersResource {
    @GET
    @Produces({"application/json", "application/xml"})
    public WebResourceList getMyResources() { ... }

    @GET
    @Path("/list")
    @Produces({"application/json", "application/xml"})
    public WebResourceList getListOfPrinters() { ... }

    @GET
    @Path("/jMakiTable")
    @Produces("application/json")
    public PrinterTableModel getTable() { ... }

    @GET
    @Path("/jMakiTree")
    @Produces("application/json")
    public TreeModel getTree() { ... }

    @GET
    @Path("/ids/{printerid}")
    @Produces({"application/json", "application/xml"})
    public Printer getPrinter(@PathParam("printerid") String printerId) { ... }

    @PUT
    @Path("/ids/{printerid}")
    @Consumes({"application/json", "application/xml"})
    public void putPrinter(@PathParam("printerid") String printerId, Printer printer) { ... }

    @DELETE
    @Path("/ids/{printerid}")
    public void deletePrinter(@PathParam("printerid") String printerId) { ... }
}
```

--------------------------------

### Start a Jakarta REST application with WebServer SPI

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/deployment.html

Initializes a WebServer instance using the WebServerFactory and a configuration builder.

```java
Application application = new MyApplication();
SeBootstrap.Configuration.Builder configBuilder = SeBootstrap.Configuration.builder();
WebServer webServer = WebServerFactory.createServer(WebServer.class, application, configBuilder.build());
```

--------------------------------

### Multipart - Sending Files

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/index.html

Example code demonstrating how to send files as part of a multipart request.

```java
import org.glassfish.jersey.media.multipart.FormDataBodyPart;
import org.glassfish.jersey.media.multipart.FormDataContentDisposition;
import org.glassfish.jersey.media.multipart.FormDataMultiPart;
import java.io.File;

FormDataMultiPart formData = new FormDataMultiPart();
FormDataContentDisposition contentDisposition = FormDataContentDisposition.name("file").fileName("report.pdf").build();
FormDataBodyPart filePart = new FormDataBodyPart(contentDisposition, new File("/path/to/report.pdf"), MediaType.APPLICATION_PDF_TYPE);
formData.bodyPart(filePart);

client.target("...").request().post(Entity.entity(formData, formData.getMediaType()));
```

--------------------------------

### MessageBodyReader Example

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

An example implementation of a MessageBodyReader for custom entity deserialization.

```java
@Provider
public class MyBeanMessageBodyReader implements MessageBodyReader<MyBean> {
    @Override
    public MyBean readFrom(Class<MyBean> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException, WebApplicationException {
        // Implementation to read MyBean from the input stream
        String content = new BufferedReader(new InputStreamReader(entityStream)).lines().collect(Collectors.joining("\n"));
        MyBean myBean = new MyBean();
        myBean.setMessage(content);
        return myBean;
    }

    // Other methods of MessageBodyReader interface
    @Override
    public boolean isReadable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) {
        return true;
    }
}
```

--------------------------------

### PUT Method Example

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/index.html

Illustrates how to create a resource method that handles HTTP PUT requests.

```java
import javax.ws.rs.PUT;
import javax.ws.rs.Path;

@Path("items")
public class ItemResource {

    @PUT
    public String updateItem() {
        return "Item updated";
    }
}
```

--------------------------------

### Configure OSGi start level in osgi.properties

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/deployment.html

Configure the final start level of the OSGi framework by modifying the osgi.properties file. This property controls the start level of the OSGi framework once the server is up and running.

```properties
# Final start level of OSGi framework. This is used by GlassFish launcher code
# to set the start level of the OSGi framework once server is up and running so that
# optional services can start. The initial start level of framework is controlled using
# the standard framework property called org.osgi.framework.startlevel.beginning
glassfish.osgi.start.level.final=3
```

--------------------------------

### Configure web.xml for a custom JAX-RS Application

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/deployment.html

Example of a web.xml structure for an application subclass named org.example.MyApplication.

```xml
<web-app version="5.0"    xmlns="https://jakarta.ee/xml/ns/jakartaee"    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">    <!-- Servlet declaration can be omitted in which case         it would be automatically added by Jersey -->    <servlet>        <servlet-name>org.example.MyApplication</servlet-name>    </servlet>    <!-- Servlet mapping can be omitted in case the Application subclass         is annotated with @ApplicationPath annotation; in such case         the mapping would be automatically added by Jersey -->    <servlet-mapping>        <servlet-name>org.example.MyApplication</servlet-name>        <url-pattern>/myresources/*</url-pattern>    </servlet-mapping></web-app>
```

--------------------------------

### Invoke a GET Request

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/client.html

Executes a GET request directly from the builder and processes the response.

```java
Response response = invocationBuilder.get();
```

```java
System.out.println(response.getStatus());
System.out.println(response.readEntity(String.class));
```

--------------------------------

### Sub-Resource Locators Example

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/index.html

Demonstrates using sub-resource locators to delegate requests to other resource classes.

```java
import javax.ws.rs.GET;
import javax.ws.rs.Path;

public class SubResource {
    @GET
    public String getSubResource() {
        return "This is the sub-resource.";
    }
}

@Path("locator-parent")
public class LocatorParentResource {

    @Path("sub")
    public SubResource getSubResourceLocator() {
        return new SubResource();
    }
}
```

--------------------------------

### Query Parameters Example

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/index.html

Demonstrates how to extract query parameters from the request URI.

```java
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.QueryParam;

@Path("search")
public class SearchResource {

    @GET
    public String search(@QueryParam("q") String query, @QueryParam("page") int page) {
        return "Searching for: " + query + ", Page: " + page;
    }
}
```

--------------------------------

### InjectionManagerClientProvider Example

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/index.html

Shows an example of using `InjectionManagerClientProvider` for custom injection in JAX-RS client requests.

```java
import org.glassfish.jersey.client.ClientConfig;
import org.glassfish.jersey.client.spi.InjectionManagerClientProvider;
import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.WebTarget;

// Assume MyInjectionManager implements InjectionManagerClientProvider
class MyInjectionManager implements InjectionManagerClientProvider {
    @Override
    public void configure(ClientConfig config) {
        // Custom configuration for injection manager
    }
    // ... other methods of InjectionManagerClientProvider
}

public class InjectionManagerClientProviderExample {

    public static void main(String[] args) {
        ClientConfig config = new ClientConfig();
        config.register(MyInjectionManager.class);

        Client client = ClientBuilder.newClient(config);
        WebTarget target = client.target("http://localhost:8080/api/resource");

        String response = target.request().get(String.class);
        System.out.println("Response: " + response);
        client.close();
    }
}
```

--------------------------------

### Fluent JAX-RS Client API Example

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/client.html

Shows a more compact way to use the JAX-RS Client API by chaining method calls for configuration, request building, and direct entity retrieval.

```java
Client client = ClientBuilder.newClient(new ClientConfig()            .register(MyClientResponseFilter.class)            .register(new AnotherClientFilter()));
String entity = client.target("http://example.com/rest")            .register(FilterForExampleCom.class)            .path("resource/helloworld")            .queryParam("greeting", "Hi World!")            .request(MediaType.TEXT_PLAIN_TYPE)            .header("some-header", "true")            .get(String.class);
```

--------------------------------

### Simple Hello World Root Resource Class

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

A basic example of a root resource class in Jersey, demonstrating the simplest way to define a RESTful resource.

```java
import javax.ws.rs.GET;
import javax.ws.rs.Path;

@Path("hello")
public class HelloWorldResource {

    @GET
    public String sayHello() {
        return "Hello, World!";
    }
}
```

--------------------------------

### Example of Possible Injections

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/index.html

Provides examples of various types of objects that can be injected into JAX-RS resource classes.

```java
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.core.HttpHeaders;
import javax.ws.rs.core.Request;
import javax.ws.rs.core.UriInfo;
import javax.ws.rs.core.SecurityContext;
import javax.ws.rs.core.Application;
import javax.ws.rs.core.Configuration;
import javax.ws.rs.core.HttpHeaders;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Request;
import javax.ws.rs.core.SecurityContext;
import javax.ws.rs.core.UriInfo;
import javax.ws.rs.ext.Providers;

@Path("injection-examples")
public class InjectionExamplesResource {

    @javax.ws.rs.core.Context
    private UriInfo uriInfo;

    @javax.ws.rs.core.Context
    private HttpHeaders httpHeaders;

    @javax.ws.rs.core.Context
    private Request request;

    @javax.ws.rs.core.Context
    private SecurityContext securityContext;

    @javax.ws.rs.core.Context
    private Application application;

    @javax.ws.rs.core.Context
    private Configuration configuration;

    @javax.ws.rs.core.Context
    private Providers providers;

    @GET
    public String showInjections(
            @javax.ws.rs.core.Context HttpHeaders headers,
            @javax.ws.rs.core.Context Request req,
            @javax.ws.rs.core.Context UriInfo uri,
            @javax.ws.rs.core.Context SecurityContext sec,
            @javax.ws.rs.core.Context Application app,
            @javax.ws.rs.core.Context Configuration config,
            @javax.ws.rs.core.Context Providers provs) {
        return "Injections successful.";
    }
}
```

--------------------------------

### JAXB Beans for JSON Notations - Initialization

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/index.html

Example of initializing JAXB beans for use in JSON serialization examples.

```java
Contact contact = new Contact();
contact.name = "John Doe";
contact.addresses = new ArrayList<>();

Address address = new Address();
address.street = "123 Main St";
address.city = "Anytown";
address.zip = "12345";
contact.addresses.add(address);
```

--------------------------------

### Create WebServer using WebServerProvider

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

Creates a WebServer instance using a specific WebServerProvider implementation, such as GrizzlyHttpServerProvider. This method provides an alternative way to select the WebServer implementation.

```java
WebServer webServer = GrizzlyHttpServerProvider.createServer(WebServer.class, application, configBuilder.build());
```

--------------------------------

### Compile and Test Project with Maven

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/user-guide.html

Invoke this command to compile the project and run its unit tests. A successful build indicates that the project is ready for execution.

```bash
mvn clean test
```

--------------------------------

### Conditional GET Support

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/index.html

Implement conditional GET requests using `If-Match`, `If-None-Match`, `If-Modified-Since`, and `If-Unmodified-Since` headers.

```java
@GET
    @Conditional("If-Modified-Since")
    public Response getResource(@HeaderParam("If-Modified-Since") String ifModifiedSince) {
        // ... logic to check modification date and return 304 if not modified ...
        return Response.ok(resource).build();
    }
```

--------------------------------

### Priorities Example

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/index.html

Illustrates how to set priorities for filters and interceptors to control their execution order.

```java
@Provider
@Priority(1000) // Higher value means lower priority
public class HighPriorityFilter implements ContainerRequestFilter { ... }
```

--------------------------------

### Configure a Client using fluent API

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/client.html

Leverage the fluent API model to configure a new client instance in a compact style.

```java
Client client = ClientBuilder.newClient(new ClientConfig()
        .register(MyClientResponseFilter.class)
        .register(new AnotherClientFilter());
```

--------------------------------

### HTTP Link Header Example

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/uris-and-links.html

An example of how a Link header might appear in an HTTP message, as defined by RFC 5988.

```http
Link: <http://example.com/TheBook/chapter2>; rel="prev"; title="previous chapter"
```

--------------------------------

### Compile and Test Project with Maven

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/getting-started.html

Use this Maven command to clean the project, compile the code, and run all unit tests. Ensure tests pass before proceeding to run the application.

```bash
mvn clean test
```

--------------------------------

### Simple GET Request with String Entity

Source: https://eclipse-ee4j.github.io/jersey.github.io/documentation/latest3x/client.html

A very simple GET request that directly returns the response entity as a Java String.

```java
String responseEntity = ClientBuilder.newClient()            .target("http://example.com").path("resource/rest")                    .request().get(String.class);
```
Tokens:
Raw