Programmazione.it v6.4
Ciao, per farti riconoscere devi fare il login. Non ti sei ancora iscritto? Che aspetti, registrati adesso!
Info Pubblicità Collabora Autori Sottoscrizioni Preferiti Bozze Scheda personale Privacy Archivio Libri Corsi per principianti Forum
Creare servizi RESTful con Spring MVC
Scritto da Francesco Carotenuto il 28-12-2011 ore 05:58
I servizi restful possono essere un'ottima soluzione per poter fornire i propri Web Service al mondo esterno, in particolare qui descriveremo come realizzare servizi RESTful a partire da web application realizzate con Struts MVC.

Per illustrare la realizzazione di un servizio restful, ci serviremo di un'applicazione che gestisce un database di capitoli di manga, in particolare illustreremo la creazione di un'interfaccia REST, che un client utilizzerà per poter effettuare le ricerche di singoli personaggi (character) presenti nei manga.

La prima cosa da fare è quello di individuare la risorsa che il servizio dovrà restituire, in questo caso si tratta del personaggio; successivamente si deve passare a definire un URI che determini univocamente un personaggio. Un esempio che risponde a queste caratteristiche ha il seguente schema:
  1. <host>/<applicationname>/<resourceName>s/<id>
Seguendo tale schema, in risposta a GET effettuato sul nostro servizio RESTful, si dovrà avere un URI simile a "http://localhost:8080/RestServer/characters/1", dove 1 è l'ID del personaggio trovato all'interno del database.

Utilizzano lo stesso URI in abbinamento a POST, potremmo indicare al servizio RESTful l'inserimento di un nuovo personaggio; se invece non è presente alcun ID, si indica la richiesta di una lista completa di tutti i personaggi dei manga.

Passando alla parte operativa, presupponiamo che l'applicazione di memorizzazione dei manga sia realizzata con un template di Spring MVC — dovremo configurare il
servlet-context.xml, dove andiamo a specificare la volontà di utilizzare le annotazioni — e l'utilizzo della classe InternalResourceViewResolver per la costruzione dell'output del servizio, specificando di voler utilizzare il package org.springframework.rest per risolvere alcune dipendenze nel bean:
  1. <?xml version="1.0" encoding="UTF-8" ?> 
  2. <beans:beans xmlns="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:beans="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:util="http://www.springframework.org/schema/util" xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
  3.  
  4.   <annotation-driven /> 
  5.  
  6.  <beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  7.   <beans:property name="prefix" value="/WEB-INF/views/" /> 
  8.   <beans:property name="suffix" value=".jsp" /> 
  9.  </beans:bean>
  10.  
  11.   <context:component-scan base-package="org.springframework.rest" /> 
  12. </beans:beans>
A questo punto è possibile definire la classe Character, che si occuperà di contenere tutte le informazioni su un singolo personaggio.
  1. package org.springframework.rest;
  2.  
  3. import java.net.URL;
  4.  
  5. import org.codehaus.jackson.annotate.JsonAutoDetect;
  6.  
  7.  
  8. @XmlRootElement
  9. public final class Character {
  10.  
  11.  private  int id;
  12.  private  String name;
  13.  private  boolean isHuman;
  14.  private URL characterUrl;
  15.  
  16.  protected Character() {
  17.  
  18.  }
  19.  
  20.  public Character(int id, String name, boolean isHuman, URL characterUrl) {
  21.   super();
  22.   this.id = id;
  23.   this.name = name;
  24.   this.isHuman = isHuman;
  25.   this.characterUrl = characterUrl;
  26.  }
  27.  
  28.  public int getId() {
  29.   return id;
  30.  }
  31.  
  32.  public void setId(int id) {
  33.   this.id = id;
  34.  }
  35.  
  36.  public String getName() {
  37.   return name;
  38.  }
  39.  
  40.  public void setName(String name) {
  41.   this.name = name;
  42.  }
  43.  
  44.  public boolean isHuman() {
  45.   return isHuman;
  46.  }
  47.  
  48.  public void setHuman(boolean isHuman) {
  49.   this.isHuman = isHuman;
  50.  }
  51.  
  52.  
  53.  public URL getCharacterUrl() {
  54.   return characterUrl;
  55.  }
  56.  
  57.  public void setCharacterUrl(URL characterUrl) {
  58.   this.characterUrl = characterUrl;
  59.  }
  60.  
  61.  @Override
  62.  public int hashCode() {
  63.   final int prime = 31;
  64.   int result = 1;
  65.   result = prime * result + id;
  66.   return result;
  67.  }
  68.  
  69.  @Override
  70.  public boolean equals(Object obj) {
  71.   if (this == obj)
  72.    return true;
  73.   if (obj == null)
  74.    return false;
  75.   if (getClass() != obj.getClass())
  76.    return false;
  77.   Character other = (Character) obj;
  78.   if (id != other.id)
  79.    return false;
  80.   return true;
  81.  }
  82.  
  83. }
Da notare l'annotazione @XmlRootElement che fa sì che il contenuto dell'intero oggetto venga mappato in una serie di tag XML.

A questo punto non ci rimane che vedere la classe HomeController, che implementa il servizio RESTful vero e proprio: tale classe è implementata come una classe Controller di Spring e inizializza una HashMap che rappresenterà il nostro database di manga.
  1. @Controller
  2. public class HomeController {
  3.  
  4.  
  5.  private static final Map<Integer, Character> characters = new HashMap<Integer, Character>();
  6.  
  7.  static {
  8.   try {
  9.    characters.put(1, new Character(1, "Totoro", false, new URL("http://animeonly.org/albums/VISINAUJI/EGIO/fourth/Mon-Voisin-Totoro/normal_totoro_001.jpg")));
  10.    characters.put(2, new Character(2, "Satsuki Kusakabe", true, new URL("http://profile.ak.fbcdn.net/hprofile-ak-ash2/48980_1802552968_7286_n.jpg")));
  11.    characters.put(3, new Character(3, "Therru", false, new URL("http://28.media.tumblr.com/tumblr_lj4ctjKA8Y1qdvyqpo1_400.jpg")));
  12.   } catch (MalformedURLException e) {
  13.    e.printStackTrace();
  14.   }
  15.  }
  16. ...
Di seguito è mostrato il metodo findCharacter, richiamato ogni qualvolta il server si ritrova con un metodo GET e un URI che finisce con /characters/{characterId} , dove per characterID c'è un numero intero che rappresenta l'ID del personaggio all'interno del database: ciò viene fatto mediante l'annotazione @RequestMapping.
  1. ...
  2.  @RequestMapping(value = "/characters/{characterId}", method = RequestMethod.GET)
  3.  @ResponseBody
  4.  public Character findCharacter(@PathVariable int characterId) {
  5.   return characters.get(characterId);
  6.  }
  7.  
  8. }
Inoltre l'annotazione @ResponseBody fa sì che l'oggetto restituito dal metodo venga scritto all'interno del body della risposta HTTP. A questo punto non ci rimane che effettuare i test del nostro servizio RESTful utilizzando strumenti quali Rest client per avere più dettagli sui test si rimanda all'articolo di JavaCodeGeek
Precedente: Visual Analyzer, guida introduttiva all'uso (9/20)
Successiva: L'opzione SET QUOTED_IDENTIFIER in SQL Server
Copyright Programmazione.it™ 1999-2014. Alcuni diritti riservati. Testata giornalistica iscritta col n. 569 presso il Tribunale di Milano in data 14/10/2002. Pagina generata in 0.384 secondi.