Scribd
Importer
29 vues27 pages

Cours Git Basic Conception

Le document présente les concepts fondamentaux des services Web RESTful, en mettant l'accent sur les règles de conception et les spécifications JAX-RS. Il décrit les différences entre SOAP et REST, ainsi que les méthodes HTTP utilisées pour interagir avec les ressources. Enfin, il aborde les formats de données comme JSON et XML, en soulignant les avantages de JSON pour l'échange de données.

Transféré par

67psydkbxn
Copyright
© © All Rights Reserved
Nous prenons très au sérieux les droits relatifs au contenu. Si vous pensez qu’il s’agit de votre contenu, signalez une atteinte au droit d’auteur ici.
Formats disponibles
Téléchargez aux formats PDF, TXT ou lisez en ligne sur Scribd
29 vues27 pages

Cours Git Basic Conception

Le document présente les concepts fondamentaux des services Web RESTful, en mettant l'accent sur les règles de conception et les spécifications JAX-RS. Il décrit les différences entre SOAP et REST, ainsi que les méthodes HTTP utilisées pour interagir avec les ressources. Enfin, il aborde les formats de données comme JSON et XML, en soulignant les avantages de JSON pour l'échange de données.

Transféré par

67psydkbxn
Copyright
© © All Rights Reserved
Nous prenons très au sérieux les droits relatifs au contenu. Si vous pensez qu’il s’agit de votre contenu, signalez une atteinte au droit d’auteur ici.
Formats disponibles
Téléchargez aux formats PDF, TXT ou lisez en ligne sur Scribd

Systèmes Distribués : Web Services : RESTful

RESTful avec JAXRS, RestController, Spring Data Rest

Mohamed Youssfi
Laboratoire Signaux Systèmes Distribués et Intelligence Artificielle (SSDIA)
ENSET, Université Hassan II Casablanca, Maroc
Email : [email protected]
Supports de cours : http://fr.slideshare.net/mohamedyoussfi9
Chaîne vidéo : http://youtube.com/mohamedYoussfi
Recherche : http://www.researchgate.net/profile/Youssfi_Mohamed/publications
Problème des Web services SOAP

Client Requête HTTP Serveur HTTP

PHP <?xml version="1.0" encoding="UTF-8"?> BanqueService


<Envelope>
.net <Header/> +conversion(double mt):double
<Body>
<conversion>
+Compte getCompte()
java <montant>12</montant> +List<Compte> getComptes()
</conversion>
</Body>
Cobol </Envelope> JaxWS Compte
-code : int
JaxB -solde: double
Réponse HTTP
<?xml version="1.0" encoding="UTF-8"?>
<Envelope>
<Body>
<conversionResponse>
<return>132</return>
</conversionResponse>
</Body>
</Envelope>
RESTful

• REST (REpresentational State Transfer)


ou RESTful est un style d’architecture pour
les systèmes hypermédia distribués, WADL (Web Application Description Language)
Equivalent à WSDL pour SOAP
• Créé par Roy Fielding en 2000 dans le
chapitre 5 de sa thèse de doctorat.
Client Web Container : Tomcat
• REST est un style d’architecture permettant HTTP, HTML
Leger
de construire des applications (Web,
Intranet, Web Service). Client Jersey JAXRS
HTTP, XML
Java Servlet
• Il s’agit d’un ensemble de conventions et
de bonnes pratiques à respecter et non Client
HTTP, JSON Web Service
d’une technologie à part entière. .net

• L’architecture REST utilise les spécifications Client Methode1()


HTTP, JSON Methode2()
originelles du protocole HTTP, plutôt que Mobile
de réinventer une surcouche (comme le
font SOAP ou XML-RPC par exemple).
Les 5 Règles de RESTful
• REST se base sur les URI (Uniform Resource Identifier) afin
• Règle n°1 : d’identifier une ressource.
• l’URI comme identifiant des ressources :
• Ainsi une application se doit de construire ses URI (et donc ses URL) de
• Respecter un standard pour construire les URLs manière précise, en tenant compte des contraintes REST.
• Règle n°2 : • Il est nécessaire de prendre en compte la hiérarchie des ressources et
• les méthode HTTP comme identifiant des opérations: la sémantique des URL pour les éditer :
POST : Pour Ajouter (Create)
•
• Liste des livres
• GET : pour consulter (Read)
• GET http://mywebsite.com/books
• PUT : pour mise à jour (Update) ou PATCH pour update partiel
• DELETE : pour supprimer (DELETE) • Filtre et tri sur les livres
• Règle n°3 : • GET http://mywebsite.com/books?fitlre=policier&tri=asc
• les réponses HTTP comme représentation des ressources • Consulter un livre
• Réponses HTTP en différents format (XML, JSON, …) en fonction de la demande du client • GET http://mywebsite.com/books/87
• Règle n°4 :
• Tous les commentaires sur un livre
• les liens comme relation entre ressources
• GET http://mywebsite.com/books/87/comments
• <a href="..." rel="payment" >Effectuer un payement</a>
• Ajoute un livre
• Règle n°5 :
• Un paramètre comme jeton d’authentification : • POST http://mywebsite.com/books
• Envoyer un jeton d’authentification différent pour chaque requête • Mettre à ajour un livre
• PUT http://mywebsite.com/books/5
• Supprimer un livre
• DELETE http://mywebsite.com/books/5
Les 5 Règles de RESTful

• Règle n°1 : • La seconde règle d’une architecture REST est


• l’URI comme identifiant des ressources : d’utiliser les verbes HTTP existants plutôt que
• Respecter un standard pour construire les URLs
d’inclure l’opération dans l’URI de la ressource.
• Règle n°2 :
• les méthode HTTP comme identifiant des opérations: • Ainsi, généralement pour une ressource, il y a 4
• POST : Pour Ajouter (Create) opérations possibles (CRUD) :
• GET : pour consulter (Read)
• PUT : pour mise à jour (Update) ou PATCH pour update partiel • Créer (create)
DELETE : pour supprimer (DELETE)
• Afficher (read)
•

• Règle n°3 :
• les réponses HTTP comme représentation des ressources • Mettre à jour (update)
• Réponses HTTP en différents format (XML, JSON, …) en fonction de la demande du
client
• Supprimer (delete)
• Règle n°4 :
• HTTP propose les verbes correspondant :
• les liens comme relation entre ressources
• <a href="..." rel="payment" >Effectuer un payement</a> • Créer (create) => POST
• Règle n°5 :
• Un paramètre comme jeton d’authentification :
• Afficher (read) => GET
• Envoyer un jeton d’authentification différent pour chaque requête • Mettre à jour (update) => PUT ou PATCH
• Supprimer (delete) => DELETE
Les 5 Règles de RESTful

• Règle n°1 : • Il est important d’avoir à l’esprit que la


• l’URI comme identifiant des ressources : réponse envoyée n’est pas une ressource,
• Respecter un standard pour construire les URLs
mais plutôt la représentation d’une ressource.
• Règle n°2 :
• les méthode HTTP comme identifiant des opérations: • Ainsi, une ressource peut avoir plusieurs
• POST : Pour Ajouter (Create) représentations dans des formats divers
• GET : pour consulter (Read)
: HTML, XML, CSV, JSON, etc.
• PUT : pour mise à jour (Update) ou PATCH pour update partiel
• DELETE : pour supprimer (DELETE) • C’est au client de définir quel format de
• Règle n°3 : réponse il souhaite reçevoir via l’entête http
• les réponses HTTP comme représentation des ressources
• Réponses HTTP en différents format (XML, JSON, …) en fonction de la demande du client
Accept.
• Règle n°4 : • Il est possible de définir plusieurs formats.
les liens comme relation entre ressources
•
• Demander une réponse en HTML
• <a href="..." rel="payment" >Effectuer un payement</a>
• GET /books
• Règle n°5 :
Host: mywebsite.com
• Un paramètre comme jeton d’authentification : Accept: application/xml
• Envoyer un jeton d’authentification différent pour chaque requête
• Demander une réponse en XML
• GET /books
Host: mywebsite.com
Accept: application/json
Les 5 Règles de RESTful

• Règle n°1 : • Les liens d’une ressource vers une autre


• l’URI comme identifiant des ressources : indiquent la présence d’une relation.
• Respecter un standard pour construire les URLs

• Règle n°2 : • Il est cependant possible de la décrire afin


• les méthode HTTP comme identifiant des opérations: d’améliorer la compréhension du système.
• POST : Pour Ajouter (Create)
• GET : pour consulter (Read) • Exemple quand on consule une ressource qui
• PUT : pour mise à jour (Update) ou PATCH pour update partiel
représente un produit d’une catégorie, on
• DELETE : pour supprimer (DELETE)

• Règle n°3 : trouve dans la description du produit un lien


• les réponses HTTP comme représentation des ressources significatif qui permet de consulter la
• Réponses HTTP en différents format (XML, JSON, …) en fonction de la demande du client
catégorie de ce produit
• Règle n°4 :
• les liens comme relation entre ressources • Ainsi l’IANA donne une liste de relation parmi
lesquelles :
• <a href="..." rel="payment" >Effectuer un payement</a>

• Règle n°5 :
• Un paramètre comme jeton d’authentification : • Contents, edit, next, last, payment, etc.
• Envoyer un jeton d’authentification différent pour chaque requête
• La liste complète sur le site de l’IANA :
• https://www.iana.org/assignments/link-
relations/link-relations.xhtml
Les 5 Règles de RESTful

• Règle n°1 :
• C’est un des sujets les plus souvent abordé
l’URI comme identifiant des ressources :
quand on parle de REST : comment
•
• Respecter un standard pour construire les URLs
authentifier une requête ?
• Règle n°2 :
les méthode HTTP comme identifiant des opérations:
• Pour authentifier les requêtes HTTP, il faut
envoyer dans la requête un jeton
•
POST : Pour Ajouter (Create)
d’authentification de la requête
•
• GET : pour consulter (Read)
• PUT : pour mise à jour (Update) ou PATCH pour update partiel
• DELETE : pour supprimer (DELETE) • Le premier Jeton X est obtenu au moment de
• Règle n°3 : l’authentification.
• les réponses HTTP comme représentation des ressources
• Réponses HTTP en différents format (XML, JSON, …) en fonction de la demande du client • Pour chaque requête HTTP, ce jeton X peut
• Règle n°4 : être mélangé avec l’URL de la requête en
• les liens comme relation entre ressources utilisant une opération de hachage.
• <a href="..." rel="payment" >Effectuer un payement</a>

• Règle n°5 : • Cette opération permet d’avoir un jeton


• Un paramètre comme jeton d’authentification : différent pour chaque requête
• Envoyer un jeton d’authentification différent pour chaque requête

• Exemple de Token d’authentification : JWT


(Json Web Token)
Spécification JEE : JAX-RS pour RESTFUL

• JAX-RS est l’acronyme Java API for RESTful Web Services


• Décrite par la JSR 311 (jcp.org/en/jsr/summary?id=311) << API >>
• Version courante de la spécification est la 1.1 JAX-RS
• Depuis la version 1.1, JAX-RS fait partie intégrante de la
spécification Java EE 6 au niveau de la pile Service Web
• Cette spécification décrit uniquement la mise en œuvre Application
de services Web REST coté serveur
• Le développements des Services Web REST repose sur
Jersey CXF REstEasy
l’utilisation de classes Java et d’annotations Référence
• Différentes implémentations de la spécification JAX-RS
sont disponibles
<< API >>
• JERSEY : implémentation de référence fournie par Oracle
Site projet : http://jersey.java.net JAX-WS
• CXF : fournie par Apache, la fusion entre XFire et Celtix
Site projet : cxf.apache.org

• RESTEasy : fournie par JBoss Site projet : Application


www.jboss.org/resteasy

• RESTlet : un des premiers framework implémentant REST JaxWSImpl CXF AXIS2


pour Java : Site projet : www.restlet.org
Référence
JAX RS: fonctionnement

Client Web Container : Tomcat


HTTP, HTML
Leger

Client Jersey JAXRS


HTTP, XML
Java Servlet
Client
HTTP, JSON Web Service
.net

Client Methode1()
HTTP, JSON Methode2()
Mobile

WADL (Web Application Description Language) Equivalent à WSDL pour SOAP


Format JSON Vs XML

// x est un objet java script


• JSON (JavaScript Object Notation – Notation Objet issue de JavaScript) est var x={a:4,b:9};
un format léger d'échange de données. // T1 est un tableau java script
var T1=[8,6,8];
• Il est facile à lire ou à écrire pour des humains. Il est aisément analysable // T2 est un tableau d'objets
ou générable par des machines. var T2=[{a:2,b:6},{a:1,b:8},{a:2,b:4}];

• JSON est un format texte complètement indépendant de tout langage, XML


mais les conventions qu'il utilise seront familières à tout programmeur <?xml version="1.0" encoding="UTF-8"?>
<comptes>
habitué aux langages descendant du C, comme par exemple : C lui-même, <compte type="courant">
<code>1</code>
C++, C#, Java, JavaScript, Perl, Python et bien d'autres.
<solde>4300</solde>
<dateCreation>2012-11-11</dateCreation>
</compte>
• Ces propriétés font de JSON un langage d'échange de données idéal. <compte type="epargne">
<code>2</code>
<solde>96000</solde>
<dateCreation>2012-12-11</dateCreation>
</compte>
</comptes>
JSON
[
{"type":"courant" , "code":1, "solde":4300,"dateCreation":1596711188451},
{"type":"epargne" , "code":2, "solde":9600,"dateCreation":1596711179308}
]
Les structures de données JSON

• En JSON, les structures de données prennent


les formes suivantes :
• Un objet, qui est un ensemble de couples nom/valeur
non ordonnés. Un objet commence par { (accolade
gauche) et se termine par } (accolade droite). Chaque
nom est suivi de : (deux-points) et les couples
nom/valeur sont séparés par , (virgule).
• Un tableau est une collection de valeurs ordonnées.
Un tableau commence par [ (crochet gauche) et se
termine par ] (crochet droit). Les valeurs sont séparées
par , (virgule).
• Une valeur peut être soit une chaîne de
caractères entre guillemets, soit un nombre,
soit true ou false ou null, soit un objet soit un tableau.
Ces structures peuvent être imbriquées.
• Une chaîne de caractères est une suite de zéro
ou plus caractères Unicode, entre guillemets, et
utilisant les échappements avec antislash. Un caractère
est représenté par une chaîne d'un seul caractère.
JAX RS: Application

Web Container : Tomcat

Client Jersey JAXRS


HTTP, XML
REST Servlet
CLIENT
HTTP, JSON Web Service Compte
REST
- Code : Long
getCompte(Long code) : Compte - Solde: double
listComptes() : List<Compte> - dateCreation:Date
Implémentation d’un Web service RESTful avec JAX RS

@Path("/banque")
• Le développement de Services Web avec JAX-RS est public class BaqueRestService {
basé sur des POJO (Plain Old Java Object) en utilisant
des annotations spécifiques à JAX-RS @Path("/comptes")
@GET
• Pas description requise dans des fichiers de @Produces(MediaType.APPLICATION_JSON)
configuration public List<Compte> listComptes() {
• Seule la configuration de la Servlet « JAX-RS » est List<Compte> cptes=new ArrayList<>();
requise pour réaliser le pont entre les requetés HTTP et ...
return cptes;
les classes Java annotées
}
• Un Service Web REST est déployé dans une application @Path("/comptes/{code}")
Web @GET
@Produces({MediaType.APPLICATION_JSON,MediaType.APPLICATION_XML})
• Contrairement aux Services Web entendus il n’y a pas
public Compte getCompte(@PathParam(value="code")Long code) {
de possibilité de développer un service REST à partir du return new Compte(1L, Math.random()*9999, new Date());
fichier de description WADL }
• Seule l’approche Botton / Up est disponible @Path("/comptes")
@POST
• Créer et annoter un POJO @Produces({MediaType.APPLICATION_JSON,MediaType.APPLICATION_XML})
• Compiler, Déployer et Tester public Compte save(Compte cp) {
...
• Possibilité d’accéder au document WADL
return cp;
• Le fichier de description WADL est génèré }
automatiquement par JAX-RS (exemple :
http://host/context/application.wadl)
Implémentation d’un Web service RESTful avec JAX RS

@Path("/comptes/{code}")
• Le développement de Services Web avec JAX-RS est @PUT
basé sur des POJO (Plain Old Java Object) en utilisant @Produces(MediaType.APPLICATION_JSON)
des annotations spécifiques à JAX-RS public Compte update(@PathParam("code")Long code,Compte cp) {
cp.setCode(code);
• Pas description requise dans des fichiers de // .. Mise à jour du compte
configuration System.out.println("Mise à jour du compte :"+cp.getCode());
• Seule la configuration de la Servlet « JAX-RS » est return cp;
requise pour réaliser le pont entre les requetés HTTP et }

les classes Java annotées


@Path("/comptes/{code}")
• Un Service Web REST est déployé dans une application @DELETE
Web @Produces(MediaType.APPLICATION_JSON)
public void delete(@PathParam("code")Long code) {
• Contrairement aux Services Web entendus il n’y a pas
// .. Suppression du compte
de possibilité de développer un service REST à partir du System.out.println("Suppression du compte :"+code);
fichier de description WADL }
• Seule l’approche Botton / Up est disponible }

• Créer et annoter un POJO


@XmlRootElement
• Compiler, Déployer et Tester public class Compte {
private Long code; private double solde;
• Possibilité d’accéder au document WADL
private Date dateCreation;
• Le fichier de description WADL est génèré // Getters et Setters
automatiquement par JAX-RS (exemple : // Constructeurs
http://host/context/application.wadl) }
Structure du projet Maven

<dependency> <plugin>
<groupId>javax</groupId> <groupId>org.apache.tomcat.maven</groupId>
<artifactId>javaee-web-api</artifactId> <artifactId>tomcat7-maven-plugin</artifactId>
<version>7.0</version> <version>2.2</version>
<scope>provided</scope> <configuration>
</dependency> <port>8080</port>
<dependency> <path>/web-api</path>
<groupId>com.sun.jersey</groupId> </configuration>
<artifactId>jersey-server</artifactId> </plugin>
<version>1.19.4</version>
</dependency>
<dependency>
<groupId>com.sun.jersey</groupId>
<artifactId>jersey-servlet</artifactId>
<version>1.19.4</version>
</dependency>
<dependency>
<groupId>com.sun.jersey</groupId>
<artifactId>jersey-json</artifactId>
<version>1.19.4</version>
</dependency>
Déploiement de Jersey : Web.xml

<?xml version="1.0" encoding="UTF-8"?>


<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">
<servlet>
<servlet-name>rs</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>service</param-value>
</init-param>
<init-param>
<param-name>com.sun.jersey.api.json.POJOMappingFeature</param-name>
<param-value>true</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>rs</servlet-name>
<url-pattern>/api/*</url-pattern>
</servlet-mapping>
</web-app>
Déploiement de Jersey : Web.xml

@Path("/") @XmlRootElement
public class BanqueRestService { @Data @AllArgsConstructor
static Map<Long,Compte> banque=new HashMap<>();
@GET @Path("/test") @NoArgsConstructor
public String test(){ return "Test Jersey"; } public class Compte {
@GET @Path("/comptes/{code}") private Long id;
@Produces({MediaType.APPLICATION_XML,MediaType.APPLICATION_JSON}) private double solde;
public Compte getCompte(@PathParam(value="code") Long code){ private Date dateCreation;
return banque.get(code);
}
}
@GET @Path("/comptes") @Produces(MediaType.APPLICATION_JSON)
public Collection<Compte> listComptes(){
return banque.values();
}
@Path("/comptes") @POST @Produces(MediaType.APPLICATION_JSON)
public Compte save(Compte cp){
if(banque.get(cp.getId())!=null) throw new RuntimeException("Ce compte existe déjà");
cp.setDateCreation(new Date());
banque.putIfAbsent(cp.getId(),cp);
return cp;
}
@Path("/comptes/{code}") @PUT @Produces(MediaType.APPLICATION_JSON)
public Compte update(@PathParam("code") Long code,Compte cp){
cp.setId(code); banque.put(cp.getId(),cp); return cp;
}
@Path("/comptes/{code}") @DELETE @Produces(MediaType.APPLICATION_JSON)
public Compte delete(@PathParam("code") Long code){
return banque.remove(code);
}
}
Test du Web service RESTful
Test du Web service RESTful
WADL : Web Application Description
Langage

• WADL est un fichier XML qui permet


de faire la description des services web
d’une application basée sur REST.
• Le WADL est généré automatiquement
par le conteneur REST.
http://localhost:8080/web-
api/api/application.wadl
• Les types de données structurés
échangés via ce web service sont
décrites par un schéma XML lié au
WSDL.
• Le schéma xml de l’application REST
peut être consulté par l’adresse de
suivante : http://localhost:8080/web-
api/api/application.wadl/xsd0.xsd
JaxRS dans un projet Spring Boot public interface CompteRepository extends JpaRepository<Compte, Long> {}

@Component
@Path("/banque") @Entity @Data
public class BanqueRestService { @AllArgsConstructor
@Autowired @NoArgsConstructor
private CompteRepository compteRepository; public class Compte {
@Id @GeneratedValue
@Path("/comptes") @GET private Long code;
@Produces(MediaType.APPLICATION_JSON) private double solde;
public List<Compte> listComptes() { private Date dateCreation;
return compteRepository.findAll();
} }
@Path("/comptes/{code}")
@GET @Produces({MediaType.APPLICATION_JSON,MediaType.APPLICATION_XML})
public Compte getCompte(@PathParam(value="code")Long code) {
return compteRepository.findOne(code);
}
@Path("/comptes")
@POST @Produces({MediaType.APPLICATION_JSON,MediaType.APPLICATION_XML})
public Compte save(Compte cp) {
compteRepository.save(cp);
return cp;
}
@Path("/comptes/{code}") @PUT @Produces(MediaType.APPLICATION_JSON)
@Configuration public Compte update(@PathParam("code")Long code,Compte cp) {
public class MyConfig { cp.setCode(code); compteRepository.save(cp);
@Bean return cp;
public ResourceConfig getJaxRSExporter() { }
ResourceConfig exporter=new ResourceConfig(); @Path("/comptes/{code}") @DELETE @Produces(MediaType.APPLICATION_JSON)
exporter.register(BanqueRestService.class); public void delete(@PathParam("code")Long code) {
return exporter; compteRepository.delete(code);
} }
} }
Web Service Restful avec Spring MVC @RestController
@RequestMapping(value="/banque")
public class BanqueRestServiceRC {
@Autowired
• Spring MVC offre des annotations qui permettent de private CompteRepository compteRepository;
créer facilement des web services Restful, sans avoir @GetMapping("/comptes")
public List<Compte> listComptes() {
besoin d’utiliser JAXRS. return compteRepository.findAll();
• Les annotations principales suivantes peuvent être }
@GetMapping("/comptes/{code}")
utilisées pour ce fait: public Compte getCompte(@PathVariable(value="code")Long code) {
• @RestController : Pour annoter le web service return compteRepository.findOne(code);
}
• @RequestMapping : Pour associer une requête HTTP quelconque @PostMapping("/comptes")
public Compte save(@RequestBody Compte cp) {
• @GetMapping : Pour associer une requête HTTP de type GET compteRepository.save(cp);
• @PostMapping : Pour associer une requête HTTP de type POST return cp;
}
• @PutMapping : Pour associer une requête HTTP de type PUT @PutMapping("/comptes/{code}")
public Compte update(@PathVariable(value="code")Long code,Compte cp) {
• @DeleteMapping : Pour associer une requête HTTP de type
cp.setCode(code);
DELETE compteRepository.save(cp);
• @RequestBody : Pour associer le corps de la requête HTTP à un return cp;
}
paramètre d’une méthode du web service
@DeleteMapping("/comptes/{code}")
• @PathVariable : Pour associer un paramètre de path URL un public void delete(@PathVariable(value="code")Long code) {
paramètre d’une méthode du web service compteRepository.delete(code);
}
• @RequestParam : Pour associer un Query param à un paramètre }
d’une méthode du web service
Web Service Restful avec Spring Data Rest

• Spring Data rest offre un moyen très


rapide qui permet d’exposer une API
Rest.
• Il suffit d’utiliser l’annotation
@RespositoryRestResource dans
l’interface Spring Data pour que
toutes les méthodes de cette
interfaces soient accessibles via une
API Rest générée automatiquement.

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>

@RepositoryRestResource
public interface CompteRepository extends JpaRepository<Compte, Long> {
}
<dependency>
Client REST Java avec Jersey <groupId>com.sun.jersey</groupId>
Client <artifactId>jersey-client</artifactId>
<version>1.19.4</version>
</dependency>
<dependency>
<groupId>com.sun.jersey</groupId> Client Java Server
<artifactId>jersey-json</artifactId>
<version>1.19.4</version> HTTP
</dependency> Jersey Client JSON API REST

ClientConfig config=new DefaultClientConfig();


Client client=Client.create(config);
URI uri=UriBuilder.fromUri("http://localhost:8080/web-api").build();
WebResource service=client.resource(uri);
WebResource resource=service.path("banque").path("comptes");
/*
* Ajouter un compte : POST http://localhost:8080/banque/comptes
* {"solde":9999,"dateCreation":1514110620417}
*/
Compte cp=new Compte(); cp.solde=9999;cp.dateCreation=new Date(); package test;
ObjectMapper mapper=new ObjectMapper(); import java.util.Date;
ClientResponse resp1=resource public class Compte {
.accept("application/json").type("application/json") public Long code;
.post(ClientResponse.class,mapper.writeValueAsString(cp)); public double solde;
System.out.println("Status Code:"+resp1.getStatus()); public Date dateCreation;
String corpsReponse=resp1.getEntity(String.class); }
System.out.println("Corps Réponse:"+corpsReponse);
Compte cp1=mapper.readValue(corpsReponse, Compte.class);
System.out.println("Code="+cp1.code); System.out.println("Solde="+cp1.solde);
System.out.println("Date Création="+cp1.dateCreation);
/* GET http://localhost:8080/banque/comptes */
String resp2=resource.get(String.class);
System.out.println(resp2);
Compte[] cptes=mapper.readValue(resp2, Compte[].class);
Client REST avec Spring RestTEmplate

@RestController Client REST Web Service


class ClientRestController{
@Autowired Spring
private RestTemplate restTemplate; Rest
private String url="http://localhost:8080/web-api/api"; Browser Web http, JSON REST D
Templat
@GetMapping("/listComptes") e
public String listCompte(){
HttpHeaders headers = new HttpHeaders();
headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
HttpEntity<String> entity = new HttpEntity<String>(headers);
ResponseEntity<String> responseEntity=restTemplate.exchange(url+"/comptes", HttpMethod.GET, entity, String.class);
String response=responseEntity.getBody();
return response; @Bean
} public RestTemplate restTemplate(){
return new RestTemplate();
@GetMapping("/listComptes2") }
public Compte listCompte2(){
Compte cp=restTemplate.getForObject(url+"/comptes/1",Compte.class);
return cp;
} @Data
@GetMapping("/listComptes3") class Compte{
public List<Compte> listCompte3(){ private Long id;
List<Compte> comptes=restTemplate.getForObject(url+"/comptes",List.class); private double solde;
return comptes; private Date dateCreation;
} }
@PostMapping("/comptes")
public Compte save(@RequestBody Compte cp){
Compte compte= restTemplate.postForObject(url+"/comptes",new HttpEntity<Compte>(cp),Compte.class);
return compte; @PostMapping("/save")
} public Compte save2(@RequestBody Compte cp){
} ResponseEntity<Compte> response= restTemplate.exchange(url+"/comptes",HttpMethod.POST,new HttpEntity<>(cp),Compte.class);
return response.getBody();
}
Application Spring Web Services : Use Case
Web Service Consummer Web Service Provider
Spring Boot IOC Containner Spring Boot IOC Containner
Web Service Web DAO
<<Entity>>
SoapClient Compte
ServiceImpl <<interface>>
CompteRepository
CompteRest Compte SOAP
Soap SOAP
API Service Spring Data
Proxy
JPA

Hibernate

WSDL JaxB2 JaxB2 JDBC

http SOAP
JSON WSDL
SGBD
Web Client SoapUI

Vous aimerez peut-être aussi