Université de Carthage

Institut Supérieur des Technologies de l’Information et des Communications (ISTIC)

TP : Web Service Spring Boot

Objectif de TP :
Créer Crud Restful WebService avec Spring Boot
Partie 1 : Installation
Java Development Kit
Spring Boot 2.x
Eclipse
Postman
Partie 2 : Créer une application Web Service
1- Sur Eclipse, Sélectionnez :
File -> New -> Project -> Spring Boot -> Spring Starter Project -> Next

2- Saisissez :

• Type: Maven Project

• Packaging: jar
• Language : Java
• Name: SpringBootCrudRestful
• Group: com.organisation
• Package: com.organisation.crudrestfull

Cliquez sur Next

Dans les étapes suivantes, vous devez sélectionner les technologies utilisées.
3- Chercher dans Available Web et cocher Spring Web
4- Cliquez sur Next -> Finish
Maintenant le projet a été créé.

Sous com.organisation.crudrestfull créez les package suivantes

com.organisation.crudrestfull.controller
com.organisation.crudrestfull.dao
com.organisation.crudrestfull.model

Sous Chaque package créez la classe java nécessaire

Code de l’application :
5- Maintenant on va coder une simple application en utilisant les fonctionnalités de webservice CRUD
La classe Employee.java représente un employé.

package com.organisation.crudrestfull.model;

public class Employee {

private String empNo;

private String empName;
private String position;

public Employee() {

public Employee(String empNo, String empName, String position) {

this.empNo = empNo;
this.empName = empName;
this.position = position;
}

public String getEmpNo() {

return empNo;
}

public void setEmpNo(String empNo) {

this.empNo = empNo;
}

public String getEmpName() {

return empName;
}

public void setEmpName(String empName) {

this.empName = empName;
}

public String getPosition() {

return position;
}

public void setPosition(String position) {

this.position = position;
}

}
La classe EmployeeDAO est annotée (annotate) par @Repository afin de notifier le Spring qu'elle est
un Spring BEAN. Cette classe comprend les méthodes qui aident à enquêter la liste des employés
(employee), à créer des employés, mettre à jour de l'information des employés et à supprimer des employés.

package com.organisation.crudrestfull.dao;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.o7planning.sbcrudrestful.model.Employee;
import org.springframework.stereotype.Repository;

@Repository
public class EmployeeDAO {

private static final Map<String, Employee> empMap = new HashMap<String, Employee>();

static {
initEmps();
}

private static void initEmps() {

Employee emp1 = new Employee("E01", "Smith", "Clerk");
Employee emp2 = new Employee("E02", "Allen", "Salesman");
Employee emp3 = new Employee("E03", "Jones", "Manager");

empMap.put(emp1.getEmpNo(), emp1);
empMap.put(emp2.getEmpNo(), emp2);
empMap.put(emp3.getEmpNo(), emp3);
}

public Employee getEmployee(String empNo) {

return empMap.get(empNo);
}

public Employee addEmployee(Employee emp) {

empMap.put(emp.getEmpNo(), emp);
return emp;
}

public Employee updateEmployee(Employee emp) {

empMap.put(emp.getEmpNo(), emp);
return emp;
}

public void deleteEmployee(String empNo) {

empMap.remove(empNo);
}

public List<Employee> getAllEmployees() {

Collection<Employee> c = empMap.values();
List<Employee> list = new ArrayList<Employee>();
list.addAll(c);
return list;
}

}
 La classe EmployeeController est annotée (annotate) par @RestController afin d'informer à Spring qu'elle
est un Spring Restful Controller

package com.organisation.crudrestfull.controller;

import java.util.List;

import com.organisation.crudrestfull.dao.EmployeeDAO;
import com.organisation.crudrestfull.model.Employee;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@RestController

public class EmployeeController {

@Autowired
private EmployeeDAO employeeDAO;

@RequestMapping("/")
@ResponseBody
public String welcome() {
return "Welcome to RestTemplate Example.";
}

@RequestMapping(value = "/employees", //
method = RequestMethod.GET, //
produces = { MediaType.APPLICATION_JSON_VALUE, //
MediaType.APPLICATION_XML_VALUE })
@ResponseBody
public List<Employee> getEmployees() {
List<Employee> list = employeeDAO.getAllEmployees();
return list;
}
@RequestMapping(value = "/employee/{empNo}", //
method = RequestMethod.GET, //
produces = { MediaType.APPLICATION_JSON_VALUE, //
MediaType.APPLICATION_XML_VALUE })
@ResponseBody
public Employee getEmployee(@PathVariable("empNo") String empNo) {
return employeeDAO.getEmployee(empNo);
}

@RequestMapping(value = "/employee", //
method = RequestMethod.POST, //
produces = { MediaType.APPLICATION_JSON_VALUE, //
MediaType.APPLICATION_XML_VALUE })
@ResponseBody
public Employee addEmployee(@RequestBody Employee emp) {

System.out.println("(Service Side) Creating employee: " + emp.getEmpNo());

return employeeDAO.addEmployee(emp);
}

@RequestMapping(value = "/employee", //
method = RequestMethod.PUT, //
produces = { MediaType.APPLICATION_JSON_VALUE, //
MediaType.APPLICATION_XML_VALUE })
@ResponseBody
public Employee updateEmployee(@RequestBody Employee emp) {

System.out.println("(Service Side) Editing employee: " + emp.getEmpNo());

return employeeDAO.updateEmployee(emp);
}

@RequestMapping(value = "/employee/{empNo}", //
method = RequestMethod.DELETE, //
produces = { MediaType.APPLICATION_JSON_VALUE,
MediaType.APPLICATION_XML_VALUE })
@ResponseBody
public void deleteEmployee(@PathVariable("empNo") String empNo) {

System.out.println("(Service Side) Deleting employee: " + empNo);

employeeDAO.deleteEmployee(empNo);
}

}
Explication de Code
Autowired : Fonction de câblage automatique de Spring Framework vous permet d'injecter implicitement la
dépendance de l'objet.
MediaType; Une sous-classe de MimeType qui ajoute la prise en charge des paramètres de qualité tels que
définis dans la spécification HTTP.
PathVariable; une annotation Spring qui indique qu'un paramètre de méthode doit être lié à une variable de
modèle d'URI.
RequestBody; l'annotation mappe le corps HttpRequest à un objet de transfert ou de domaine,
RequestMapping; utilisé pour mapper les requêtes Web sur des classes de gestionnaire et/ou des méthodes
de gestionnaire spécifiques.
ResponseBody; annotation qui lie une valeur de retour de méthode au corps de la réponse Web.
RestController; une annotation pratique qui est elle-même annotée avec @Controller et @ResponseBody .
Cette annotation est appliquée à une classe pour la marquer en tant que gestionnaire de requêtes.

L'attribut produce sert à spécifier un URL qui créera seulement (renverra au user) les données sous quel
format. Par exemple : "application/json", "application/xml".

Exécution de code
6- Pour tester notre exemple on va utiliser Postman
Ouvrir Postman et procédez comme suit :
Sélectionner la fonctionnalité
Appeler l’URL
Cliquer sur send

Test GET http://localhost:8080/employees

Test de POST http://localhost:8080/employee

Remplir les champs d’employer dans la section body
Test UPDATE http://localhost:8080/employee
Modifier les champs d’un employé dans la section body

Test Delete http://localhost:8080/employee/{empoNo}

Pour créer une application Web service avec spring boot et my sql il suffit de

Il faut ajouter les dépendances nécessaires :

spring data JPA : pour simplifie la programmation de la couche d'accès aux données en implémentant
les opérations de persistance les plus courantes conformément aux meilleures pratiques.
spring boot : pour simplifie grandement le développement d'applications d'entreprise Java et d'API
RESTful en fournissant une configuration par défaut et les meilleures pratiques.
hibernate : c’est un framework de mappage objet/relationnel par défaut intégré à Spring Data JPA.

Créer une base de données my sql spécifier les informations de connexion à la base de données.
Modifier le fichier application.properties dans le répertoire src/main/resources avec le contenu suivant