TP : Développer un service web multi

connecteurs avec Rest API, GraphQL API,

SOAP API et gRPC API

Architecture des composants d’entreprise

 Table des matières

I. Objectif du TP ................................................................................................................................................... 2

II. Prérequis .......................................................................................................................................................... 2

III. Développement de l’application ................................................................................................................. 2

a. Le diagramme de classe ............................................................................................................................... 2

b. Clone de l’application .................................................................................................................................. 3

c. Tester l’api GRAPHQL .................................................................................................................................. 4

d. Développement du connecteur Rest (Rest API) ......................................................................................... 5

1. Développement du contrôleur Rest ........................................................................................................ 5

2. Configuration de l’api OpenAPI et SWAGGER ......................................................................................10

3. Importer l’interface du SW au niveau de Postman ..............................................................................11

e. Développement du connecteur SOAP (SOAP API)....................................................................................13

1. Le fichier [Link] .................................................................................................................................13

2. Le contrôleur SOAP ................................................................................................................................14

3. Le serveur SOAP .....................................................................................................................................16

4. Personnaliser le lien de votre SW SOAP ...............................................................................................17

5. Tester avec SoapUI ................................................................................................................................17

f. Développement du connecteur gRPC .......................................................................................................19

1. Le fichier [Link] .................................................................................................................................19

2. Le fichier [Link]..............................................................................................................................21

3. Build du projet .......................................................................................................................................24

4. Configuration du port du serveur gRPC ................................................................................................24

5. Le contrôleur ..........................................................................................................................................24

6. Test de l’API gRPC ..................................................................................................................................27

Conclusion ..............................................................................................................................................................28

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 1

I. Objectif du TP
Mettre en œuvre un micro service avec Spring Boot avec les trois couches :
- La couche DAO (Data Access Layer) : avec Spring Data JPA.
- La couche métier (Business Layer).
- La couche présentation (Web Layer) avec les APIs suivantes :
 GraphQL API.
 REST API.
 SOAP API.
 gRPC API.

II. Prérequis
- IntelliJ IDEA ;
- JDK version 17 ;
- Une connexion Internet pour permettre à Maven de télécharger les librairies.
- Le TP relatif à GraphQL.
NB : Ce TP a été réalisé avec IntelliJ IDEA 2023.2.3 (Ultimate Edition).

III. Développement de l’application

a. Le diagramme de classe
Nous allons prendre le même diagramme de classe que nous avons implémenté dans l’atelier relatif à GraphQL
([Link] dans lequel nous avons utilisé GraphQL. Pour
rappel, le service web offre les services suivants :
- Consulter la liste des clients de la banque.
- Consulter un client par son numéro d’identité.
- Modifier un client par son numéro d’identité.
- Supprimer un client par son numéro d’identité.
- Consulter la liste des comptes bancaires.
- Consulter un compte bancaire par son RIB.
- Effecteur des virements d’un compte vers un autre compte.

Le diagramme de classe est le suivant :

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 2

 - Un client peut avoir un ou plieurs comptes bancaires.
- Sur un compte bancaire, le client peut effectuer une ou plusieurs transactions.
- Un client est un utilisateur.
- Un utilisateur (exemple : agent guichet) peut effectuer une ou plusieurs transactions.
- Un compte bancaire peut avoir les statuts suivants : OPENED, CLOSED ou bien BLOCKED.
- Une transaction est de deux types : DEBIT ou CREDIT.
- Aucune transaction ne peut être effectuée sur un compte « CLOSED » ou bien « BLOCKED ».
- Pour effectuer un virement, le solde du compte bancaire de l’émetteur doit être supérieur au montant
du virement.
- L’identité du client est unique.
- Le nom d’utilisateur (username) est unique.

b. Clone de l’application
- Ouvrir un terminal dans Intellig.
- Se positionner par exemple dans le dossier c:\workspace\tp7 et lancer la commande suivante :
git clone [Link]

- Vérifier que le projet nommé bank-service-graphql a été bien crée.

- Renommer le projet par exemple bank-service-multi-connector.
- Modifier également le nom de l’ArtifactID dans [Link] et ouvrir le projet avec Intellig.
- Renommer le package [Link] par [Link].

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 3

 - Créer le package [Link] et déplacer dans ce dernier les
classes contrôleurs suivantes : BankAccountGraphqlController, CustomerGraphqlController,
TransactionGraphqlController.
c. Tester l’api GRAPHQL
- Lancer la méthode main de la classe de démarrage.
- Accéder à la console h2 : [Link] et vérifier que les tables USER, CUSTOMER,
BANK_ACCOUNT et BANK_ACCOUNT_TRANSACTION ont été bien créées et initialisées :

- Aller au lien : [Link] et tester les services en utilisant

l’explorateur de GRAPHIQL :

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 4

Remarque :
Remarquez que grâce à l’interface de GraphiQL, vous avez pu connaître la liste des Endpoint fournis par le SW
et également comment les consommer : vous venez de développer une API GraphQL.

NB : Pour plus de détails par rapport au développement du service web avec GraphQL, veuillez se référer à
l’atelier n°4 dont le code source est disponible sur GITHUB : [Link]
[Link].

d. Développement du connecteur Rest (Rest API)

1. Développement du contrôleur Rest
- Ajouter la dépendance suivante au niveau du fichier [Link] :
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
</dependency>

Explications :
- Pour la validation des données envoyées dans la requête. Par défaut, Spring utilise
comme implémentation de l’API Bean Validation le Framework Hibernate
Validator. L’api propose plusieurs annotations comme par exemple : @NotNull,
@NotEmpty, @Max, ….
- Avec l’api Bean Validation, vous pouvez implémenter vos propres règles de gestion.

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 5

 - Créer le package [Link] et ensuite créer la classe
ErrorResponse suivante :
package [Link];

import [Link];
import [Link];

import [Link];

@Getter
@Setter
public class ErrorResponse {
private String message;
private List<String> details;

public ErrorResponse(String message, List<String> details) {

super();
[Link] = message;
[Link] = details;
}
}

Explications :
- Cette classe sera utilisée pour l’envoi des messages d’erreurs dans la réponse Rest.
- Au niveau de la couche Service, nous allons vérifier les règles de gestion métier si elles ont été
bien respectées, le cas échéant nous allons lever l’exception BusinessException. Cette même
exception sera interceptée par la suite par la classe ExceptionHandlerController

- Créer le package [Link] et ensuite créer les classes

suivantes : CustomerRestController, BankAccountRestController, TransactionRestController et
ExceptionHandlerController :

 La classe CustomerRestController :
package [Link];

import [Link];
import [Link].*;
import [Link];
import [Link];
import [Link];
import [Link].*;

import [Link];

@RestController
@RequestMapping("/api/rest/customer")
@CrossOrigin("[Link]
Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 6
public class CustomerRestController {
private final ICustomerService customerService;

public CustomerRestController(ICustomerService customerService) {

[Link] = customerService;
}

@GetMapping("/all")
List<CustomerDto> customers() {
return [Link]();
}

@GetMapping
CustomerDto customerByIdentity(@RequestParam(value = "identity") String identity) {
return [Link](identity);
}

@PostMapping("/create")
public ResponseEntity<AddCustomerResponse> createCustomer(@RequestBody @Valid AddCustomerRequest dto) {
return new ResponseEntity<>([Link](dto), [Link]);
}

@PutMapping("/update/{identityRef}")
public ResponseEntity<UpdateCustomerResponse> updateCustomer(@PathVariable String identityRef, @RequestBody
@Valid UpdateCustomerRequest dto) {
return new ResponseEntity<>([Link](identityRef, dto), [Link]);
}

@DeleteMapping("/delete/{identityRef}")
public ResponseEntity<String> deleteCustomer(@PathVariable String identityRef) {
[Link](identityRef);
return new ResponseEntity<>([Link]("Customer with identity %s is removed", identityRef), [Link]);
}
}

Explications :
- Remarquer que nous avons annoté la classe par @CrossOrigin("[Link] . En
fait, l’objectif est de permettre à l’application Javascript (que nous allons développer dans un
autre atelier en utilisant React) de consommer le service web Rest de notre couche Back-end.

 La classe BankAccountRestController :
package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link].*;

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 7

import [Link];

@RestController
@RequestMapping("/api/rest/bank")
@CrossOrigin("[Link]
public class BankAccountRestController {
private final IBankAccountService bankAccountService;

public BankAccountRestController(IBankAccountService bankAccountService) {

[Link] = bankAccountService;
}

@GetMapping("/all")
List<BankAccountDto> bankAccounts() {
return [Link]();
}

@GetMapping
BankAccountDto bankAccountByRib(@RequestParam(value = "rib") String rib) {
return [Link](rib);
}

@PostMapping("/create")
public ResponseEntity<AddBankAccountResponse> addBankAccount(@Valid @RequestBody AddBankAccountRequest
dto) {
return new ResponseEntity<>([Link](dto), [Link]);
}
}

 La classe TransactionRestController :

package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link].*;

import [Link];

@AllArgsConstructor
@RestController
@RequestMapping("/api/rest/transaction")
@CrossOrigin("[Link]
public class TransactionRestController {

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 8

 private ITransactionService transactionService;
private CommonTools commonTools;

@PostMapping("/create")
public ResponseEntity<AddWirerTransferResponse> addWirerTransfer(@Valid @RequestBody
AddWirerTransferRequest dto) {
return new ResponseEntity<>([Link](dto), [Link]);
}

@GetMapping
public List<TransactionDto> getTransactions(GetTransactionListRequest dto) {
return [Link](dto);
}
}

 La classe ExceptionHandlerController :
package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];
@ControllerAdvice
public class ExceptionHandlerController extends ResponseEntityExceptionHandler {
@Override
protected ResponseEntity<Object> handleMethodArgumentNotValid(MethodArgumentNotValidException ex,
HttpHeaders headers, HttpStatusCode status, WebRequest request) {
List<String> details = new ArrayList<>();
for (ObjectError error : [Link]().getAllErrors()) {
[Link]([Link]());
}
ErrorResponse error = new ErrorResponse("Validation Failed", details);
return new ResponseEntity(error, HttpStatus.BAD_REQUEST);
}

@ExceptionHandler(value = [Link])
public final ResponseEntity<Object> handleBusinessException(BusinessException ex, WebRequest request) {
List<String> details = new ArrayList<>();
[Link]([Link]());
ErrorResponse error = new ErrorResponse("Functional errors", details);
return new ResponseEntity(error, HttpStatus.BAD_REQUEST);
}

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 9

 @ExceptionHandler([Link])
public final ResponseEntity<Object> handleOtherExceptions(Exception ex, WebRequest request) {
List<String> details = new ArrayList<>();
[Link]([Link]());
ErrorResponse error = new ErrorResponse("Technical error, please consult your administrator", details);
return new ResponseEntity(error, HttpStatus.INTERNAL_SERVER_ERROR);
}
}

Explications :
- Avec cette classe, nous avons implémenté le Design Pattern AOP (Aspect Oriented
Programming). En effet, nous avons externalisé le code ayant pour vocation le traitement des
exceptions de notre couche métier. Remarquer que cette classe intercepte et traite 03 types
d’exceptions :
 Les exceptions levées par l’api Bean Validation (il s’agit de la classe exception :
MethodArgumentNotValidException) qui sont traitées par la méthode
handleMethodArgumentNotValid. Remarquer que la classe
ExceptionHandlerController hérite de la classe ResponseEntityExceptionHandler de
Spring et ceci afin que la JVM exécute la méthode redéfinie au lieu d’exécuter la
méthode de la classe ResponseEntityExceptionHandler (le principe de
Polymorphisme).
 Les exceptions de type BusinessException levées par la couche Service.
 Les autres exceptions (par exemple : panne de réseau, …).

2. Configuration de l’api OpenAPI et SWAGGER

- Ajouter la dépendance suivante au niveau du fichier [Link] :
<dependency>
<groupId>[Link]</groupId>
<artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
<version>2.2.0</version>
</dependency>

- Ajouter les 03 lignes suivantes au niveau du fichier [Link] :

[Link]=/api/rest/docs
[Link]=/api/rest/docs-ui
[Link]=method

Explications :
- La clé [Link] permet de personnaliser le lien pour accéder à l’interface
d’OpenAPI.

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 10

 - La clé [Link] permet de personnaliser le lien pour accéder à l’interface de
Swagger afin de tester les EndPoints de notre SW Rest.
- La clé [Link] permet de trier par ordre alphabétique les
méthodes au niveau de l’interface de Swagger.

3. Importer l’interface du SW au niveau de Postman

- Lancer Postman et suivre les étapes suivantes :

- Cliquer sur APIs.

- Cliquer sur Import. La fenêtre suivante s’affiche :

- Entrer le lien de l’interface JSON généré par OpenAPI : [Link] la fenêtre

suivante s’affiche :

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 11

 - Cocher « Postman Collection » et cliquer sur Import. Vérifier que le lien de l’interface de votre WS a
été bien exploité par Postman et que les Endpoints ont été toutes affichées comme montré ci-après :

- Vous pouvez tester par exemple l’EndPoint /api/rest/customer/all en cliquant tout simplement sur
l’Endpoint comme montré ci-après :

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 12

 Remarquer que grâce à l’interface générée par OpenAPI, vous pouvez tester les EndPoint de votre WS
très facilement.
Remarque :
Remarquez que grâce à l’api OpenAPI V3, vous avez pu connaître la liste des Endpoint fournis par le SW et
également comment les consommer : vous venez de développer une API REST.

e. Développement du connecteur SOAP (SOAP API)

1. Le fichier [Link]
Ajouter les dépendances suivantes au niveau du fichier [Link] :
<dependency>
<groupId>[Link]</groupId>
<artifactId>jaxws-ri</artifactId>
<version>4.0.2</version>
<type>pom</type>
</dependency>

<dependency>
<groupId>[Link]</groupId>
<artifactId>cxf-spring-boot-starter-jaxws</artifactId>
<version>4.0.3</version>
</dependency>

Explications :
- La dépendance jaxws-ri est l’implémentation de référence de l’api JAX WS (Java Architecture based
XML for Web Service), il s’agit du projet Metro de la communauté Jakarta (le site officiel de Metro est
[Link]

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 13

 - La dépendance cxf-spring-boot-starter-jaxws ([Link] permet
d’enregistrer la servlet fournie par Apache CXF (CXFServlet) avec l’URL « /services/* » au niveau du
conteneur de Spring pour accéder aux Endpoints de JAX-WS. Apache CXF est une implémentation de
l’api JAX WS.

2. Le contrôleur SOAP
- Créer le package [Link]
- Créer ensuite la classe BankSoapController suivante :
package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link].*;
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];

@Component
@WebService(serviceName = "BankWS")
@SOAPBinding
@AllArgsConstructor
public class BankSoapController {

private final IBankAccountService bankAccountService;

private final ICustomerService customerService;
private ITransactionService transactionService;
private CommonTools commonTools;

@WebMethod

/**
*
@WebResult was user in order to replace return balise
by Customer balise in SOAP Response.
*/
@WebResult(name = "Customer")

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 14

 public List<CustomerDto> customers() {
return [Link]();
}

@WebMethod
/**
* @WebResult was user in order to replace return balise
* by Customer balise in SOAP Response.
*/
@WebResult(name = "Customer")
public CustomerDto customerByIdentity(@WebParam(name = "identity") String identity) {
return [Link](identity);
}

@WebMethod
/**
* @WebResult was user in order to replace return balise
* by Customer balise in SOAP Response.
*/
@WebResult(name = "Customer")
public AddCustomerResponse createCustomer(@WebParam(name = "Customer") AddCustomerRequest dto) {
return [Link](dto);
}

/**
* @WebResult was user in order to replace return balise
* by BankAccount balise in SOAP Response.
*/
@WebResult(name = "BankAccount")
@WebMethod
public List<BankAccountDto> bankAccounts() {
return [Link]();
}

@WebMethod
/**
* @WebResult was user in order to replace return balise
* by BankAccount balise in SOAP Response.
*/
@WebResult(name = "BankAccount")
public BankAccountDto bankAccountByRib(@WebParam(name = "rib") String rib) {
return [Link](rib);
}

/**
* @WebResult was user in order to replace return balise
* by BankAccount balise in SOAP Response.
*/
@WebResult(name = "BankAccount")
@WebMethod
public AddBankAccountResponse createBankAccount(@WebParam(name = "bankAccountRequest")
AddBankAccountRequest dto) {
return [Link](dto);
}

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 15

 /**
* @WebResult was user in order to replace return balise
* by Transaction balise in SOAP Response.
*/
@WebResult(name = "Transaction")
@WebMethod
public AddWirerTransferResponse createWirerTransfer(@WebParam(name = "wirerTransferRequest")
AddWirerTransferRequest dto) {
return [Link](dto);
}

/**
* @WebResult was user in order to replace return balise
* by Transaction balise in SOAP Response.
*/
@WebResult(name = "Transaction")
@WebMethod
public List<TransactionDto> getTransactions(@WebParam(name = "dto") GetTransactionListRequest dto) {
return [Link](dto);
}

@WebResult(name = "Customer")
@WebMethod
public UpdateCustomerResponse changeCustomer(@WebParam(name = "identityRef") String identityRef,
@WebParam(name = "dto") UpdateCustomerRequest dto) {
return [Link](identityRef, dto);
}

@WebMethod
public String deleteCustomer(@WebParam(name = "identityRef") String identityRef) {
return [Link](identityRef);
}
}

3. Le serveur SOAP
- Créer la classe CxfConfig suivante :
package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

@Configuration
@AllArgsConstructor

public class CxfConfig {

private Bus bus;

private BankSoapController bankSoapController;

@Bean
public EndpointImpl bankWSEndpoint() {

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 16

 EndpointImpl endpoint = new EndpointImpl(bus, bankSoapController);
[Link]("/BankService");
return endpoint;
}
}

Explications :
- La méthode bankWSEndpoint() ci-dessus permet d’enregistrer le Servlet de CXF au niveau du
conteneur. Le SW SOAP nommé « /bankService » est accessible via lien
[Link]

4. Personnaliser le lien de votre SW SOAP

- Pour changer le lien de votre WS SOAP, il suffit d’ajouter la ligne suivante au niveau du fichier
[Link] :
[Link]=/api/soap

5. Tester avec SoapUI

- Lancer l’application.
- Lancer le lien suivant : [Link] et vérifier que le fichier WSDL
a été bien généré :

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 17

 - Lancer SoapUI :

- Cliquer sur SOAP comme montré ci-dessus, la fenêtre suivante s’affiche :

- Entrer l’URL du WS, le nom de votre projet de test et cliquer sur le bouton OK. Vérifier que tous les
Endpoints de votre WS sont listés :

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 18

 - Pour tester par exemple customers, cliquer sur ce dernier et cliquer sur la flèche au milieu comme
montré ci-après :

Remarque :
Remarquez que grâce au fichier WSDL, vous avez pu connaître la liste des Endpoint fournis par le SW et
également comment les consommer : vous venez de développer une API SOAP.

f. Développement du connecteur gRPC

1. Le fichier [Link]
- Dans la balise <properties> du fichier [Link], ajouter les lignes suivantes :
<[Link]>3.25.0</[Link]>
<[Link]>1.59.0</[Link]>
<[Link]>[Link]</[Link]>
<[Link]>[Link]</[Link]>

- Ajouter les dépendances suivantes au niveau du fichier [Link] :

<!-- Needed for gRPC WS -->
<dependency>
<groupId>[Link]</groupId>
<artifactId>grpc-stub</artifactId>
<version>${[Link]}</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>grpc-protobuf</artifactId>
<version>${[Link]}</version>

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 19

</dependency>

<dependency>
<groupId>[Link]</groupId>
<artifactId>protobuf-java</artifactId>
<version>${[Link]}</version>
</dependency>
<dependency>
<!-- Java 9+ compatibility - Do NOT update to 2.0.0 -->
<groupId>[Link]</groupId>
<artifactId>[Link]-api</artifactId>
<version>2.1.1</version>
<optional>true</optional>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>grpc-server-spring-boot-starter</artifactId>
<version>${[Link]}</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>grpc-server-spring-boot-autoconfigure</artifactId>
<version>${[Link]}</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>[Link]-api</artifactId>
<version>1.3.2</version>
</dependency>

- Ajouter ensuite le plugin ci-dessous :

<plugin>
<groupId>[Link].os72</groupId>
<artifactId>protoc-jar-maven-plugin</artifactId>
<version>3.11.4</version>
<executions>
<execution>
<phase>generate-sources</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<includeMavenTypes>direct</includeMavenTypes>
<inputDirectories>
<include>src/main/resources</include>
</inputDirectories>
<outputTargets>
<outputTarget>
<type>java</type>
<outputDirectory>src/main/java</outputDirectory>
</outputTarget>
<outputTarget>
<type>grpc-java</type>
<pluginArtifact>[Link]:protoc-gen-grpc-java:1.15.0</pluginArtifact>
<outputDirectory>src/main/java</outputDirectory>

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 20

 </outputTarget>
</outputTargets>
</configuration>
</execution>
</executions>
</plugin>

2. Le fichier [Link]
Créer le fichier src/resources/[Link] suivant :
syntax = "proto3";
option java_package = "[Link]";
service BankService{
rpc customers(CustomersRequest) returns (CustomersResponse);
rpc customerByIdentity(CustomerByIdentityRequest) returns (CustomerByIdentityResponse);
rpc createCustomer(CreateCustomerRequest) returns (CreateCustomerResponse);
rpc updateCustomer(UpdateCustomerRequest) returns (UpdateCustomerResponse);
rpc deleteCustomer(DeleteCustomerRequest) returns (DeleteCustomerResponse);

rpc bankAccounts(BankAccountsRequest) returns (BankAccountsResponse);

rpc bankAccountByRib(BankAccountByRibRequest) returns (BankAccountByRibResponse);
rpc addBankAccount(AddBankAccountRequest) returns (AddBankAccountResponse);

rpc addWirerTransfer(AddWirerTransferRequest) returns (AddWirerTransferResponse);

rpc getTransactions(GetTransactionsRequest) returns (GetTransactionsResponse);

message CustomersRequest {
}

message CustomersResponse {
repeated CustomerDTO customers = 1;
}
message CustomerDTO {
int64 id = 1;
string username = 2;
string identityRef = 3;
string firstname = 4;
string lastname = 5;
}

message CustomerByIdentityRequest {
string identityRef = 1;
}

message CustomerByIdentityResponse {
CustomerDTO customer = 1;
}

message CreateCustomerRequest {
string username = 1;
string identityRef = 2;
string firstname = 3;
string lastname = 4;

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 21

}

message CreateCustomerResponse {
string message = 1;
CustomerDTO customer = 2;

message UpdateCustomerRequest {
string identityRef = 1;
UpdatedCustomerDTO updatedCustomer = 2;
}

message UpdatedCustomerDTO {
string username = 2;
string firstname = 4;
string lastname = 5;
}

message UpdateCustomerResponse {
string message = 1;
CustomerDTO customer = 2;
}

message DeleteCustomerRequest {
string identityRef = 1;
}

message DeleteCustomerResponse {
string message = 1;
}

message BankAccountDto {
int64 id = 1;
string rib = 2;
double amount = 3;
string createdAt = 4;
string accountStatus = 5;
CustomerDTO customer = 6;
}

message BankAccountsRequest {

message BankAccountsResponse {
repeated BankAccountDto bankAccount = 1;
}

message BankAccountByRibRequest {
string rib = 1;
}

message BankAccountByRibResponse {
BankAccountDto bankAccount = 1;

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 22

}

message AddBankAccountRequest {
string rib = 1;
double amount = 2;
string customerIdentityRef = 3;
}

message AddBankAccountResponse {
string message = 1;
BankAccountDto bankAccount = 2;
}

message AddWirerTransferRequest {
string ribFrom = 1;
string ribTo = 2;
double amount = 3;
string username = 4;
}

message AddWirerTransferResponse {
string message = 1;
TransactionDto transactionFrom = 2;
TransactionDto transactionTo = 3;
}

message GetTransactionsRequest {
string rib = 1;
string dateTo = 2;
string dateFrom = 3;
}

message GetTransactionsResponse {
repeated TransactionDto transaction = 1;
}

message UserDto {
string username = 1;
string firstname = 2;
string lastname = 3;
}

message TransactionDto {
string createdAt = 1;
string transactionType = 2;
double amount = 3;
BankAccountDto bankAccount = 4;
UserDto user = 5;
}

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 23

3. Build du projet

- Lancer la commande clean install de Maven pour que le plugin gRPC puisse générer le stub. Vérifier
que les classes du stub ont été bien générées dans le package
[Link].

4. Configuration du port du serveur gRPC

- Le serveur gRPC sera démarré par défaut au port 9999. Pour changer ce dernier, il suffit d’ajouter la
ligne suivante au niveau du fichier [Link]. dans ce cas le serveur gRPC sera démarré au
port 4444.
[Link]=4444

5. Le contrôleur
- Créer le package [Link] et ensuite créer la classe
BankGrpcController suivante :

package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link].*;
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];

@Component
@AllArgsConstructor
@GrpcService
public class BankGrpcController extends [Link] {
private ICustomerService customerService;
private IBankAccountService bankAccountService;
private ModelMapper modelMapper;

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 24

 private ITransactionService transactionService;

@Override
public void customers([Link] request, StreamObserver<[Link]>
responseObserver) {
List<CustomerDto> customers = [Link]();
[Link] response = [Link]().
addAllCustomers(
[Link]().map(customerDto ->
[Link](customerDto, [Link]).build()).
collect([Link]())).
build();
[Link](response);
[Link]();
}

@Override
public void customerByIdentity([Link] request,
StreamObserver<[Link]> responseObserver) {
CustomerDto customerDto = [Link]([Link]());
[Link] response = [Link]().
setCustomer([Link](customerDto, [Link]).build()).
build();
[Link](response);
[Link]();
}

@Override
public void createCustomer([Link] request, StreamObserver<[Link]>
responseObserver) {
AddCustomerResponse addCustomerResponse = [Link]([Link](request,
[Link]));
[Link] response = [Link]().
setMessage([Link]()).
setCustomer([Link](addCustomerResponse, [Link]).build()).
build();
[Link](response);
[Link]();
}

@Override
public void updateCustomer([Link] request, StreamObserver<[Link]>
responseObserver) {

UpdateCustomerResponse updateCustomerResponse = [Link](

[Link](), [Link]([Link](), [Link]));
[Link] response = [Link]().
setMessage([Link]()).
setCustomer([Link](updateCustomerResponse, [Link]).build()).
build();
[Link](response);
[Link]();
}

@Override
public void deleteCustomer([Link] request, StreamObserver<[Link]>
responseObserver) {

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 25

 String message = [Link]([Link]());
[Link] response = [Link]().
setMessage(message).
build();
[Link](response);
[Link]();
}

@Override
public void bankAccounts([Link] request, StreamObserver<[Link]>
responseObserver) {
List<BankAccountDto> bankAccounts = [Link]();
[Link] response = [Link]().
addAllBankAccount(
[Link]().
map(bankAccount -> [Link](bankAccount, [Link]).build()).
collect([Link]())).
build();
[Link](response);
[Link]();
}

@Override
public void bankAccountByRib([Link] request,
StreamObserver<[Link]> responseObserver) {
BankAccountDto bankAccount = [Link]([Link]());

[Link] response = [Link]().

setBankAccount([Link](bankAccount, [Link]).build()).
build();
[Link](response);
[Link]();
}

@Override
public void addBankAccount([Link] request, StreamObserver<[Link]>
responseObserver) {
AddBankAccountResponse addBankAccountResponse = [Link](
[Link](request, [Link]));
[Link] response = [Link]().
setMessage([Link]()).
setBankAccount([Link](addBankAccountResponse, [Link]).build()).
build();
[Link](response);
[Link]();
}

@Override
public void addWirerTransfer([Link] request,
StreamObserver<[Link]> responseObserver) {
AddWirerTransferResponse addWirerTransferResponse =
[Link]([Link](request, [Link]));
[Link] response = [Link]().
setMessage([Link]()).
setTransactionFrom([Link]([Link](),
[Link]).build()).

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 26

 setTransactionTo([Link]([Link](),
[Link]).build()).
build();
[Link](response);
[Link]();
}

@Override
public void getTransactions([Link] request, StreamObserver<[Link]>
responseObserver) {
List<TransactionDto> transactions = [Link]([Link](request,
[Link]));
[Link] response = [Link]().
addAllTransaction([Link]().
map(transactionDto -> [Link](transactionDto, [Link]).build()).
collect([Link]())).
build();
[Link](response);
[Link]();

}
}

6. Test de l’API gRPC

- Lancer votre application et vérifier que le serveur gRPC est bien démarré comme montré ci-dessous :

- Lancer BloomRPC, configurer l’URL du serveur ([Link]:4444), ajouter le fichier [Link] et vérifier
que les méthodes fournies par le service gRPC sont bien listées au niveau De l’interface de BloomRPC :

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 27

 - Pour tester par exemple le service customers, cliquer sur ce dernier ensuite cliquer sur la flèche au
centre et vérifier que le serveur a bien envoyé la liste des clients :

Remarque :
Remarquez que grâce au fichier PROTO, vous avez pu connaître la liste des Endpoint fournis par le SW et
également comment les consommer : vous venez de développer une API gRPC.

Conclusion
Le code source de cet atelier est disponible sur GITHUB :
[Link]

Service web avec plusieurs API : Rest, SOAP, GRAPHQL et gRPC 28