Tutorial su Jersey Java

Tutorial
Java

Benvenuti al tutorial di Java Jersey. Di recente ho iniziato a lavorare su un progetto di servizi Web Restful utilizzando il framework JAX-RS Jersey.

Cos’è il framework Java Jersey?

Il progetto Java Jersey segue l’API JAX-RS, che viene utilizzata per creare servizi Web Restful in Java.

1. Chi dovrebbe utilizzare questo tutorial?

Questo tutorial è rivolto ai programmatori Java interessati a sviluppare e distribuire servizi Web Restful utilizzando l’API JAX-RS e JAXB.

2. Prerequisiti

Lo scopo di questo tutorial è utilizzare l’API Jersey per creare servizi Web Restful e invocare il servizio Web utilizzando un programma client Java e testare il servizio Web utilizzando lo strumento. È necessaria una comprensione di base di Java, servizi Web, XML, Maven e qualsiasi server applicativo (JBoss/Tomcat) per comprendere il tutorial con facilità.

3. Software e Strumenti

  • Versione JDK 1.8.0_131
  • Apache Maven 3.5.3
  • Mac OS X 10.13.4
  • Tomcat 8.5.16
  • Eclipse Java EE IDE Oxygen 4.7.3

Creazione del Progetto Maven di Jersey in Eclipse

Crea un “Dynamic Web Project” in Eclipse e poi convertilo in un progetto Maven. Questo ci fornirà un progetto di base per un’applicazione web basata su Maven. Ho specificato GroupId come com.journaldev.jersey e artifactID come my-jersey-project, ma puoi specificare quello che preferisci. Una volta completato lo sviluppo del nostro progetto, la struttura del progetto sarà simile all’immagine sottostante.

Spiegazione del Progetto di Servizio Web Restful di Java Jersey

1. pom.xml: Dettagli di configurazione del progetto, nota le dipendenze fornite da jersey, altri dettagli sono comuni per qualsiasi progetto Maven simile.

<project xmlns="https://maven.apache.org/POM/4.0.0"
	xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.journaldev.jersey</groupId>
	<artifactId>my-jersey-project</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>

	<dependencies>
		<dependency>
			<groupId>com.sun.jersey</groupId>
			<artifactId>jersey-server</artifactId>
			<version>1.14</version>
		</dependency>
		<dependency>
			<groupId>com.sun.jersey</groupId>
			<artifactId>jersey-servlet</artifactId>
			<version>1.14</version>
		</dependency>
		<dependency>
			<groupId>com.sun.jersey</groupId>
			<artifactId>jersey-client</artifactId>
			<version>1.14</version>
		</dependency>
	</dependencies>

	<build>
		<finalName>My-Jersey-Project</finalName>
		<plugins>
			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.7.0</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>
			<plugin>
				<artifactId>maven-war-plugin</artifactId>
				<version>3.0.0</version>
				<configuration>
					<warSourceDirectory>WebContent</warSourceDirectory>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

2. EmpRequest.java: Bean Java per l’oggetto di richiesta. La cosa importante da notare qui è l’annotazione @XmlRootElement per mappare la classe a un elemento XML.

package com.journaldev.model;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name = "empRequest")
public class EmpRequest {
	private int id;
	private String name;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

3. EmpResponse.java: Bean Java per l’oggetto di risposta.

package com.journaldev.model;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name = "empResponse")
public class EmpResponse {
	private int id;
	private String name;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

}

4. ErrorResponse.java: Bean Java che verrà inviato come risposta in caso di eccezione.

package com.journaldev.model;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name = "errorResponse")
public class ErrorResponse {

	private String errorCode;
	private int errorId;

	public String getErrorCode() {
		return errorCode;
	}

	public void setErrorCode(String errorCode) {
		this.errorCode = errorCode;
	}

	public int getErrorId() {
		return errorId;
	}

	public void setErrorId(int errorId) {
		this.errorId = errorId;
	}

}

5. EmpNotFoundException.java: Una classe di eccezione normale lanciata nel servizio web.

package com.journaldev.exception;

public class EmpNotFoundException extends Exception {

	private static final long serialVersionUID = 4351720088030656859L;
	private int errorId;

	public int getErrorId() {
		return errorId;
	}

	public EmpNotFoundException(String msg, int errorId) {
		super(msg);
		this.errorId = errorId;
	}

	public EmpNotFoundException(String msg, Throwable cause) {
		super(msg, cause);
	}
}

6. web.xml: Descrittore di distribuzione per il servizio web. Quindi ogni richiesta con l’URI https://<HOST>:<PORT>/My-Jersey-Project/rest/* verrà elaborata dal servlet Jersey ServletContainer. Il valore init-param passato per “com.sun.jersey.config.property.packages” definisce il pacchetto in cui jersey cercherà le classi del servizio web. Questa proprietà deve puntare alle tue classi di risorse. Cerca anche le classi di risorse nelle sotto-pacchetti.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xmlns="https://java.sun.com/xml/ns/javaee"
	xsi:schemaLocation="https://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
	id="WebApp_ID" version="3.0">
	<display-name>My Jersey Project</display-name>

	<!-- Jersey Servlet configurations -->
	<servlet>
		<servlet-name>Jersey REST Service</servlet-name>
		<servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
		<init-param>
			<param-name>com.sun.jersey.config.property.packages</param-name>
			<param-value>com.journaldev</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>Jersey REST Service</servlet-name>
		<url-pattern>/rest/*</url-pattern>
	</servlet-mapping>
	<!-- Jersey Servlet configurations -->

</web-app>

7. EmpRouter.java: Classe di risorse che gestisce diversi tipi di richieste.

  • @Path(“/emp”) – Tutte le richieste con l’URI https://<HOST>:<PORT>/My-Jersey-Project/rest/emp/ verranno elaborate da questa classe di risorse.
  • @Path(“/getEmp”) – Tutte le richieste con URI https://<HOST>:<PORT>/My-Jersey-Project/rest/emp/getEmp saranno elaborate da questo metodo.
  • @POST – Questa annotazione definisce che il metodo HTTP utilizzato dovrebbe essere POST. Alcuni altri valori possibili sono @GET, @PUT, @DELETE
  • @Consumes(MediaType.APPLICATION_XML) – Il metodo accetta un elemento XML
  • @Produces(MediaType.APPLICATION_XML) – Il metodo restituisce un elemento XML
package com.journaldev.router;

import com.journaldev.exception.EmpNotFoundException;
import com.journaldev.model.*;

import javax.ws.rs.Consumes;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.xml.bind.JAXBElement;

@Path("/emp")
public class EmpRouter {

	@POST
	@Path("/getEmp")
	@Consumes(MediaType.APPLICATION_XML)
	@Produces(MediaType.APPLICATION_XML)
	public Response getEmp(JAXBElement<EmpRequest> empRequest)
			throws EmpNotFoundException {
		EmpResponse empResponse = new EmpResponse();
		if (empRequest.getValue().getId() == 1) {
			empResponse.setId(empRequest.getValue().getId());
			empResponse.setName(empRequest.getValue().getName());
		} else {
			throw new EmpNotFoundException("Wrong ID", empRequest.getValue()
					.getId());
		}
		return Response.ok(empResponse).build();
	}
}

8. EmpNotFoundExceptionMapper.java: Classe Exception Mapper che mappa EmpNotFoundException a un oggetto Response. La classe dovrebbe avere l’annotazione @Provider. Questa classe dovrebbe trovarsi nel pacchetto fornito per le classi di risorsa in web.xml. L’implementazione del metodo toResponse() genera l’oggetto ErrorResponse e lo imposta come Entità nell’oggetto Response con stato INTERNAL_SERVER_ERROR.

package com.journaldev.exceptionmapper;

import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.ext.ExceptionMapper;
import javax.ws.rs.ext.Provider;

import com.journaldev.exception.EmpNotFoundException;
import com.journaldev.model.ErrorResponse;

@Provider
public class EmpNotFoundExceptionMapper implements
		ExceptionMapper<EmpNotFoundException> {

	public EmpNotFoundExceptionMapper() {
	}
	
	public Response toResponse(
			EmpNotFoundException empNotFoundException) {
		ErrorResponse errorResponse = new ErrorResponse();
		errorResponse.setErrorId(empNotFoundException.getErrorId());
		errorResponse.setErrorCode(empNotFoundException.getMessage());
		return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(
				errorResponse).type(
				MediaType.APPLICATION_XML).build();

	}

}

Il nostro servizio web è pronto, basta compilarlo per creare il file WAR e distribuirlo sul server dell’applicazione.

Esempio di Cliente Jersey

Possiamo utilizzare il Cliente Jersey per chiamare il nostro servizio web e ottenere una risposta in modo programmato. EmpClient.java: Questo è un programma di esempio in Java tramite il quale stiamo invocando il nostro servizio web. Stiamo utilizzando l’API del Cliente Jersey per invocare il servizio e in base allo stato della risposta stiamo analizzando l’entità della risposta nella classe EmpResponse o ErrorResponse.

package com.journaldev.client;

import javax.ws.rs.core.MediaType;

import com.journaldev.model.EmpRequest;
import com.journaldev.model.EmpResponse;
import com.journaldev.model.ErrorResponse;
import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.ClientResponse;
import com.sun.jersey.api.client.WebResource;

public class EmpClient {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String uri = "https://localhost:8080/My-Jersey-Project/rest/emp/getEmp";
		EmpRequest request = new EmpRequest();
		// impostiamo id a 1 per una risposta OK
		request.setId(2);
		request.setName("PK");
		try {
			Client client = Client.create();
			WebResource r = client.resource(uri);
			ClientResponse response = r.type(MediaType.APPLICATION_XML).post(ClientResponse.class, request);
			System.out.println(response.getStatus());
			if (response.getStatus() == 200) {
				EmpResponse empResponse = response.getEntity(EmpResponse.class);
				System.out.println(empResponse.getId() + "::" + empResponse.getName());
			} else {
				ErrorResponse exc = response.getEntity(ErrorResponse.class);
				System.out.println(exc.getErrorCode());
				System.out.println(exc.getErrorId());
			}
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
	}

}

Risposta di Successo Risposta di Errore

Riassunto

In questo post, abbiamo imparato come creare un servizio web REST utilizzando l’API Jersey. Abbiamo anche esaminato il Cliente Jersey per invocare le nostre API REST tramite un programma Java.

Puoi controllare il codice completo del progetto dal nostro Repository GitHub.

Source:
https://www.digitalocean.com/community/tutorials/jersey-java-tutorial