Tutorial sui servizi Web Restful in Java

Benvenuti al Tutorial sulle Restful Web Services in Java. REST è l’acronimo di REpresentational State Transfer. REST è uno stile architetturale per lo sviluppo di applicazioni che possono essere accessibili tramite la rete. Lo stile architetturale REST è stato presentato da Roy Fielding nella sua tesi di dottorato nel 2000.

Restful Web Services

Le Restful Web Services sono un’architettura client-server senza stato in cui i web service sono risorse e possono essere identificati tramite le loro URI. Le applicazioni client REST possono utilizzare i metodi HTTP GET/POST per invocare i servizi web Restful. REST non specifica alcun protocollo specifico da utilizzare, ma nella maggior parte dei casi viene utilizzato su HTTP/HTTPS. Rispetto ai servizi web SOAP, questi sono leggeri e non seguono alcuno standard. Possiamo utilizzare XML, JSON, testo o qualsiasi altro tipo di dati per la richiesta e la risposta.

API per le Restful Web Services in Java

L’API per le Restful Web Services in Java (JAX-RS) è l’API Java per la creazione di servizi web REST. JAX-RS utilizza le annotazioni per semplificare lo sviluppo e la distribuzione dei servizi web. JAX-RS fa parte di JDK, quindi non è necessario includere nulla per utilizzare le sue annotazioni.

Servizi Web Restful Annotations

Alcune delle importanti annotazioni JAX-RS sono:

• @Path: utilizzato per specificare il percorso relativo della classe e dei metodi. Possiamo ottenere l’URI di un servizio web scansionando il valore dell’annotazione Path.
• @GET, @PUT, @POST, @DELETE e @HEAD: utilizzati per specificare il tipo di richiesta HTTP per un metodo.
• @Produces, @Consumes: utilizzati per specificare i tipi di richiesta e risposta.
• @PathParam: utilizzato per collegare il parametro del metodo al valore del percorso analizzandolo.

Servizi Web Restful e SOAP

1. SOAP è un protocollo mentre REST è uno stile architetturale.
2. Le applicazioni server e client SOAP sono strettamente accoppiate e legate al contratto WSDL, mentre non c’è alcun contratto nei servizi web REST e clienti.
3. La curva di apprendimento è facile per REST rispetto ai servizi web SOAP.
4. I tipi di richiesta e risposta dei servizi web REST possono essere XML, JSON, testo, ecc., mentre SOAP lavora solo con XML.
5. JAX-RS è l’API Java per i servizi web REST, mentre JAX-WS è l’API Java per i servizi web SOAP.

Implementazioni API REST

Esistono due implementazioni principali dell’API JAX-RS.

1. Jersey: Jersey è l’implementazione di riferimento fornita da Sun. Per utilizzare Jersey come nostra implementazione JAX-RS, è sufficiente configurare il suo servlet nel file web.xml e aggiungere le dipendenze necessarie. Si noti che l’API JAX-RS fa parte del JDK e non di Jersey, quindi è necessario aggiungere le sue librerie di dipendenza nella nostra applicazione.
2. RESTEasy: RESTEasy è il progetto JBoss che fornisce l’implementazione JAX-RS.

Tutorial sui servizi web RESTful in Java

Vediamo quanto è facile creare un servizio web RESTful utilizzando Jersey e successivamente RESTEasy. Esporremo i seguenti metodi tramite HTTP e utilizzeremo l’estensione Chrome Postman per testarli.

Servizi web RESTful con Jersey

Crea un progetto web dinamico e poi convertilo in Maven per ottenere lo scheletro del tuo progetto di servizi web. L’immagine seguente mostra la struttura del progetto finale. Esaminiamo le dipendenze di Jersey che abbiamo nel file pom.xml.

<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>JAXRS-Example</groupId>
  <artifactId>JAXRS-Example</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  
  <dependencies>
        <dependency>
            <groupId>com.sun.jersey</groupId>
            <artifactId>jersey-server</artifactId>
            <version>1.19</version>
        </dependency>
        <dependency>
            <groupId>com.sun.jersey</groupId>
            <artifactId>jersey-servlet</artifactId>
            <version>1.19</version>
        </dependency>
        <dependency>
            <groupId>com.sun.jersey</groupId>
            <artifactId>jersey-client</artifactId>
            <version>1.19</version>
        </dependency>
  </dependencies>
  
  <build>
    <sourceDirectory>src</sourceDirectory>
    <plugins>
      <plugin>
        <artifactId>maven-war-plugin</artifactId>
        <version>2.6</version>
        <configuration>
          <warSourceDirectory>WebContent</warSourceDirectory>
          <failOnMissingWebXml>false</failOnMissingWebXml>
        </configuration>
      </plugin>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.3</version>
        <configuration>
          <source>1.7</source>
          <target>1.7</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

Non è necessario aggiungere le dipendenze jersey-client, ma se stai scrivendo un programma Java per invocare un servizio web REST utilizzando Jersey, è richiesto. Ora esaminiamo il descrittore di distribuzione per imparare come configurare Jersey per creare la nostra applicazione web.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns="https://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="https://xmlns.jcp.org/xml/ns/javaee https://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
  <display-name>JAXRS-Example</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>/*</url-pattern>
  </servlet-mapping>
  <!-- Jersey Servlet configurations -->

</web-app>

Questo è tutto ciò che è necessario per integrare Jersey nella nostra applicazione web, nel nostro codice Java utilizzeremo le annotazioni JAX-RS. Nota il valore del parametro di inizializzazione com.sun.jersey.config.property.packages per fornire il pacchetto che verrà analizzato per le risorse e i metodi del servizio web.

Esempi di classi modello REST

Innanzitutto creeremo due bean modello – Person per i dati della nostra applicazione e Response per inviare la risposta ai sistemi client. Poiché invieremo una risposta XML, i bean dovrebbero essere annotati con @XmlRootElement, quindi abbiamo questa classe.

package com.journaldev.jaxrs.model;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement (name="person")
public class Person {
	private String name;
	private int age;
	private int id;

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}
	
	@Override
	public String toString(){
		return id+"::"+name+"::"+age;
	}

}

package com.journaldev.jaxrs.model;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class Response {

	private boolean status;
	private String message;

	public boolean isStatus() {
		return status;
	}

	public void setStatus(boolean status) {
		this.status = status;
	}

	public String getMessage() {
		return message;
	}

	public void setMessage(String message) {
		this.message = message;
	}
}

Servizi Tutorial Web REST

In base alla nostra struttura URI, di seguito è riportata l’interfaccia del servizio e il relativo codice di implementazione.

package com.journaldev.jaxrs.service;

import com.journaldev.jaxrs.model.Person;
import com.journaldev.jaxrs.model.Response;

public interface PersonService {

	public Response addPerson(Person p);
	
	public Response deletePerson(int id);
	
	public Person getPerson(int id);
	
	public Person[] getAllPersons();

}

package com.journaldev.jaxrs.service;


import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

import com.journaldev.jaxrs.model.Person;
import com.journaldev.jaxrs.model.Response;

@Path("/person")
@Consumes(MediaType.APPLICATION_XML)
@Produces(MediaType.APPLICATION_XML)
public class PersonServiceImpl implements PersonService {

	private static Map<Integer,Person> persons = new HashMap<Integer,Person>();
	
	@Override
	@POST
    @Path("/add")
	public Response addPerson(Person p) {
		Response response = new Response();
		if(persons.get(p.getId()) != null){
			response.setStatus(false);
			response.setMessage("Person Already Exists");
			return response;
		}
		persons.put(p.getId(), p);
		response.setStatus(true);
		response.setMessage("Person created successfully");
		return response;
	}

	@Override
	@GET
    @Path("/{id}/delete")
	public Response deletePerson(@PathParam("id") int id) {
		Response response = new Response();
		if(persons.get(id) == null){
			response.setStatus(false);
			response.setMessage("Person Doesn't Exists");
			return response;
		}
		persons.remove(id);
		response.setStatus(true);
		response.setMessage("Person deleted successfully");
		return response;
	}

	@Override
	@GET
	@Path("/{id}/get")
	public Person getPerson(@PathParam("id") int id) {
		return persons.get(id);
	}
	
	@GET
	@Path("/{id}/getDummy")
	public Person getDummyPerson(@PathParam("id") int id) {
		Person p = new Person();
		p.setAge(99);
		p.setName("Dummy");
		p.setId(id);
		return p;
	}

	@Override
	@GET
	@Path("/getAll")
	public Person[] getAllPersons() {
		Set<Integer> ids = persons.keySet();
		Person[] p = new Person[ids.size()];
		int i=0;
		for(Integer id : ids){
			p[i] = persons.get(id);
			i++;
		}
		return p;
	}

}

La maggior parte del codice è autoesplicativa, prenditi del tempo per familiarizzare con le annotazioni JAX-RS @Path, @PathParam, @POST, @GET, @Consumes e @Produces.

Test dei servizi Web RESTful

Ecco fatto. Il nostro servizio Web è pronto, esportalo come file WAR e inseriscilo nella directory webapps di Tomcat o distribuiscilo in qualsiasi altro contenitore a tua scelta. Di seguito sono riportati alcuni test eseguiti utilizzando l’estensione Postman per Chrome per questo servizio Web. Nota che dobbiamo fornire i valori Accept e Content-Type come “application/xml” nell’intestazione della richiesta, come mostrato nell’immagine sottostante.

• getDummy
• aggiungi
• ottenere
• getAll
• elimina

Questo è tutto per la creazione di servizi web utilizzando l’implementazione Jersey JAX-RS. Come puoi vedere, la maggior parte del codice utilizza le annotazioni JAX-RS e Jersey è collegato tramite il descrittore di distribuzione e le dipendenze.

Esempio di servizi web RESTful RESTEasy

Utilizzeremo tutta la logica aziendale sviluppata nel progetto Jersey, ma anziché apportare modifiche allo stesso progetto, ho creato un nuovo progetto. Crea un progetto web dinamico e convertilo in un progetto Maven. Quindi copia tutte le classi Java – Person, Response, PersonService e PersonServiceImpl. Di seguito è riportato il progetto finale dopo aver completato tutte le modifiche. Aggiungi le dipendenze RESTEasy seguenti nel file pom.xml.

<dependency>
	<groupId>org.jboss.resteasy</groupId>
	<artifactId>resteasy-jaxrs</artifactId>
	<version>3.0.13.Final</version>
</dependency>
<dependency>
	<groupId>org.jboss.resteasy</groupId>
	<artifactId>resteasy-jaxb-provider</artifactId>
	<version>3.0.13.Final</version>
</dependency>

Di seguito è riportato il file web.xml in cui stiamo configurando il servlet Resteasy.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns="https://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="https://xmlns.jcp.org/xml/ns/javaee https://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
  <display-name>JAXRS-Example-RestEasy</display-name>
     
    <listener>
      <listener-class>
         org.jboss.resteasy.plugins.server.servlet.ResteasyBootstrap
      </listener-class>
   	</listener>
   
    <servlet>
        <servlet-name>resteasy-servlet</servlet-name>
        <servlet-class>
            org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher
        </servlet-class>
        <init-param>
        <param-name>javax.ws.rs.Application</param-name>
        <param-value>com.journaldev.jaxrs.resteasy.app.MyApp</param-value>
    </init-param>
    </servlet>
  
    <servlet-mapping>
        <servlet-name>resteasy-servlet</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
	
</web-app>

Nota il init-param dove stiamo fornendo la classe MyApp come valore, qui stiamo estendendo la classe javax.ws.rs.core.Application come mostrato di seguito.

package com.journaldev.jaxrs.resteasy.app;

import java.util.HashSet;
import java.util.Set;

import javax.ws.rs.core.Application;

import com.journaldev.jaxrs.service.PersonServiceImpl;

public class MyApp extends Application {
	
	private Set<Object> singletons = new HashSet<Object>();

	public MyApp() {
		singletons.add(new PersonServiceImpl());
	}

	@Override
	public Set<Object> getSingletons() {
		return singletons;
	}

}

Test dei servizi web RESTEasy

Ecco fatto. Il nostro servizio web è pronto con l’implementazione JAX-RS di RESTEasy. Di seguito sono riportati alcuni output del test dell’estensione chrome Postman.

• getDummy
• aggiungi
• ottenere

È tutto per il Tutorial sui servizi web RESTful, spero tu abbia imparato sulle annotazioni JAX-RS e capito i benefici di avere un’API standard che ci ha aiutato a riutilizzare il codice e passare così facilmente da Jersey a RESTEasy.